diff --git a/benchmarks/compilation/codegen/src/main.rs b/benchmarks/compilation/codegen/src/main.rs
index be862ad2..aad88357 100644
--- a/benchmarks/compilation/codegen/src/main.rs
+++ b/benchmarks/compilation/codegen/src/main.rs
@@ -1,4 +1,4 @@
-use proc_macro2::TokenStream;
+use proc_macro2::{Literal, TokenStream};
 use quote::{format_ident, quote};
 use std::path::PathBuf;
 
@@ -10,15 +10,14 @@ fn main() -> anyhow::Result<()> {
 
     let src_dir = bench_dir.join("src");
 
-    let structs_number = 10;
-    let fields_number = 50;
-
-    std::fs::write(
-        src_dir.join(format!(
-            "structs_{structs_number}_fields_{fields_number}.rs"
-        )),
-        structs_n_fields_n(structs_number, fields_number).to_string(),
-    )?;
+    for (structs_number, fields_number) in [(100, 10), (10, 50)] {
+        std::fs::write(
+            src_dir.join(format!(
+                "structs_{structs_number}_fields_{fields_number}.rs"
+            )),
+            structs_n_fields_n(structs_number, fields_number).to_string(),
+        )?;
+    }
 
     println!("Running cargo fmt in {}", bench_dir.display());
 
@@ -38,10 +37,20 @@ fn structs_n_fields_n(structs_number: usize, fields_number: usize) -> TokenStrea
         .map(|i| format_ident!("x{i}"))
         .collect::<Vec<_>>();
 
+    let field_values = (1..=fields_number)
+        .map(Literal::usize_unsuffixed)
+        .collect::<Vec<_>>();
+
     (1..=structs_number)
         .map(move |i| {
             let struct_name = format_ident!("Struct{i}");
+            let builder_name = format_ident!("Struct{i}Builder");
+            let usage_fn = format_ident!("struct{i}");
 
+            // Every struct is built once with all setters called. This way
+            // the benchmark measures the cost of the builder usage in addition
+            // to the cost of the builder definition. The `cfg`s follow the
+            // same order of priority as the `Builder` import in `lib.rs`.
             quote! {
                 #[cfg_attr(
                     any(
@@ -54,6 +63,35 @@ fn structs_n_fields_n(structs_number: usize, fields_number: usize) -> TokenStrea
                 pub struct #struct_name {
                     #( #field_names: i32, )*
                 }
+
+                #[cfg(any(feature = "bon", feature = "typed-builder"))]
+                pub fn #usage_fn() -> #struct_name {
+                    #struct_name::builder()
+                        #( .#field_names(#field_values) )*
+                        .build()
+                }
+
+                #[cfg(all(
+                    feature = "derive_builder",
+                    not(any(feature = "bon", feature = "typed-builder")),
+                ))]
+                pub fn #usage_fn() -> #struct_name {
+                    #builder_name::default()
+                        #( .#field_names(#field_values) )*
+                        .build()
+                        .unwrap()
+                }
+
+                #[cfg(not(any(
+                    feature = "bon",
+                    feature = "typed-builder",
+                    feature = "derive_builder",
+                )))]
+                pub fn #usage_fn() -> #struct_name {
+                    #struct_name {
+                        #( #field_names: #field_values, )*
+                    }
+                }
             }
         })
         .collect()
diff --git a/benchmarks/compilation/results.md b/benchmarks/compilation/results.md
index 5217a0e9..f0429786 100644
--- a/benchmarks/compilation/results.md
+++ b/benchmarks/compilation/results.md
@@ -1,10 +1,10 @@
 | Command                                |      Mean [s] | Min [s] | Max [s] |     Relative |
 | :------------------------------------- | ------------: | ------: | ------: | -----------: |
-| `structs_100_fields_10 bon`            | 2.340 ± 0.019 |   2.315 |   2.364 | 20.86 ± 1.37 |
-| `structs_100_fields_10 typed-builder`  | 1.831 ± 0.015 |   1.806 |   1.859 | 16.32 ± 1.07 |
-| `structs_100_fields_10 derive_builder` | 1.026 ± 0.013 |   1.009 |   1.048 |  9.14 ± 0.61 |
-| `structs_100_fields_10 `               | 0.113 ± 0.010 |   0.092 |   0.125 |  1.01 ± 0.11 |
-| `structs_10_fields_50 bon`             | 2.096 ± 0.009 |   2.080 |   2.109 | 18.69 ± 1.22 |
-| `structs_10_fields_50 typed-builder`   | 2.088 ± 0.014 |   2.067 |   2.115 | 18.61 ± 1.22 |
-| `structs_10_fields_50 derive_builder`  | 0.449 ± 0.022 |   0.391 |   0.470 |  4.00 ± 0.33 |
-| `structs_10_fields_50 `                | 0.112 ± 0.007 |   0.086 |   0.116 |         1.00 |
+| `structs_100_fields_10 bon`            | 2.321 ± 0.023 |   2.282 |   2.351 | 21.40 ± 1.92 |
+| `structs_100_fields_10 typed-builder`  | 1.677 ± 0.023 |   1.649 |   1.726 | 15.47 ± 1.40 |
+| `structs_100_fields_10 derive_builder` | 1.043 ± 0.023 |   1.013 |   1.084 |  9.62 ± 0.88 |
+| `structs_100_fields_10 `               | 0.135 ± 0.015 |   0.114 |   0.162 |  1.24 ± 0.18 |
+| `structs_10_fields_50 bon`             | 2.098 ± 0.022 |   2.065 |   2.135 | 19.35 ± 1.74 |
+| `structs_10_fields_50 typed-builder`   | 1.996 ± 0.021 |   1.970 |   2.029 | 18.41 ± 1.65 |
+| `structs_10_fields_50 derive_builder`  | 0.434 ± 0.012 |   0.415 |   0.450 |  4.00 ± 0.37 |
+| `structs_10_fields_50 `                | 0.108 ± 0.010 |   0.096 |   0.129 |         1.00 |
diff --git a/benchmarks/compilation/src/lib.rs b/benchmarks/compilation/src/lib.rs
index 7674dd09..a97f812f 100644
--- a/benchmarks/compilation/src/lib.rs
+++ b/benchmarks/compilation/src/lib.rs
@@ -2,7 +2,8 @@
     missing_docs,
     missing_debug_implementations,
     dead_code,
-    rustdoc::missing_crate_level_docs
+    rustdoc::missing_crate_level_docs,
+    clippy::must_use_candidate
 )]
 
 cfg_if::cfg_if! {
diff --git a/benchmarks/compilation/src/structs_100_fields_10.rs b/benchmarks/compilation/src/structs_100_fields_10.rs
index 2f1f0c43..044c2540 100644
--- a/benchmarks/compilation/src/structs_100_fields_10.rs
+++ b/benchmarks/compilation/src/structs_100_fields_10.rs
@@ -14,6 +14,55 @@ pub struct Struct1 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct1() -> Struct1 {
+    Struct1::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct1() -> Struct1 {
+    Struct1Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct1() -> Struct1 {
+    Struct1 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -30,6 +79,55 @@ pub struct Struct2 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct2() -> Struct2 {
+    Struct2::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct2() -> Struct2 {
+    Struct2Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct2() -> Struct2 {
+    Struct2 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -46,6 +144,55 @@ pub struct Struct3 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct3() -> Struct3 {
+    Struct3::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct3() -> Struct3 {
+    Struct3Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct3() -> Struct3 {
+    Struct3 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -62,6 +209,55 @@ pub struct Struct4 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct4() -> Struct4 {
+    Struct4::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct4() -> Struct4 {
+    Struct4Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct4() -> Struct4 {
+    Struct4 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -78,6 +274,55 @@ pub struct Struct5 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct5() -> Struct5 {
+    Struct5::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct5() -> Struct5 {
+    Struct5Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct5() -> Struct5 {
+    Struct5 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -94,6 +339,55 @@ pub struct Struct6 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct6() -> Struct6 {
+    Struct6::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct6() -> Struct6 {
+    Struct6Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct6() -> Struct6 {
+    Struct6 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -110,6 +404,55 @@ pub struct Struct7 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct7() -> Struct7 {
+    Struct7::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct7() -> Struct7 {
+    Struct7Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct7() -> Struct7 {
+    Struct7 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -126,6 +469,55 @@ pub struct Struct8 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct8() -> Struct8 {
+    Struct8::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct8() -> Struct8 {
+    Struct8Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct8() -> Struct8 {
+    Struct8 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -142,6 +534,55 @@ pub struct Struct9 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct9() -> Struct9 {
+    Struct9::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct9() -> Struct9 {
+    Struct9Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct9() -> Struct9 {
+    Struct9 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -158,6 +599,55 @@ pub struct Struct10 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct10() -> Struct10 {
+    Struct10::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct10() -> Struct10 {
+    Struct10Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct10() -> Struct10 {
+    Struct10 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -174,6 +664,55 @@ pub struct Struct11 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct11() -> Struct11 {
+    Struct11::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct11() -> Struct11 {
+    Struct11Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct11() -> Struct11 {
+    Struct11 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -190,6 +729,55 @@ pub struct Struct12 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct12() -> Struct12 {
+    Struct12::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct12() -> Struct12 {
+    Struct12Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct12() -> Struct12 {
+    Struct12 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -206,6 +794,55 @@ pub struct Struct13 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct13() -> Struct13 {
+    Struct13::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct13() -> Struct13 {
+    Struct13Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct13() -> Struct13 {
+    Struct13 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -222,6 +859,55 @@ pub struct Struct14 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct14() -> Struct14 {
+    Struct14::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct14() -> Struct14 {
+    Struct14Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct14() -> Struct14 {
+    Struct14 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -238,6 +924,55 @@ pub struct Struct15 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct15() -> Struct15 {
+    Struct15::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct15() -> Struct15 {
+    Struct15Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct15() -> Struct15 {
+    Struct15 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -254,6 +989,55 @@ pub struct Struct16 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct16() -> Struct16 {
+    Struct16::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct16() -> Struct16 {
+    Struct16Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct16() -> Struct16 {
+    Struct16 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -270,6 +1054,55 @@ pub struct Struct17 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct17() -> Struct17 {
+    Struct17::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct17() -> Struct17 {
+    Struct17Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct17() -> Struct17 {
+    Struct17 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -286,6 +1119,55 @@ pub struct Struct18 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct18() -> Struct18 {
+    Struct18::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct18() -> Struct18 {
+    Struct18Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct18() -> Struct18 {
+    Struct18 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -302,6 +1184,55 @@ pub struct Struct19 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct19() -> Struct19 {
+    Struct19::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct19() -> Struct19 {
+    Struct19Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct19() -> Struct19 {
+    Struct19 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -318,6 +1249,55 @@ pub struct Struct20 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct20() -> Struct20 {
+    Struct20::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct20() -> Struct20 {
+    Struct20Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct20() -> Struct20 {
+    Struct20 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -334,6 +1314,55 @@ pub struct Struct21 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct21() -> Struct21 {
+    Struct21::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct21() -> Struct21 {
+    Struct21Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct21() -> Struct21 {
+    Struct21 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -350,6 +1379,55 @@ pub struct Struct22 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct22() -> Struct22 {
+    Struct22::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct22() -> Struct22 {
+    Struct22Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct22() -> Struct22 {
+    Struct22 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -366,6 +1444,55 @@ pub struct Struct23 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct23() -> Struct23 {
+    Struct23::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct23() -> Struct23 {
+    Struct23Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct23() -> Struct23 {
+    Struct23 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -382,6 +1509,55 @@ pub struct Struct24 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct24() -> Struct24 {
+    Struct24::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct24() -> Struct24 {
+    Struct24Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct24() -> Struct24 {
+    Struct24 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -398,6 +1574,55 @@ pub struct Struct25 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct25() -> Struct25 {
+    Struct25::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct25() -> Struct25 {
+    Struct25Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct25() -> Struct25 {
+    Struct25 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -414,6 +1639,55 @@ pub struct Struct26 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct26() -> Struct26 {
+    Struct26::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct26() -> Struct26 {
+    Struct26Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct26() -> Struct26 {
+    Struct26 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -430,6 +1704,55 @@ pub struct Struct27 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct27() -> Struct27 {
+    Struct27::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct27() -> Struct27 {
+    Struct27Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct27() -> Struct27 {
+    Struct27 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -446,6 +1769,55 @@ pub struct Struct28 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct28() -> Struct28 {
+    Struct28::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct28() -> Struct28 {
+    Struct28Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct28() -> Struct28 {
+    Struct28 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -462,6 +1834,55 @@ pub struct Struct29 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct29() -> Struct29 {
+    Struct29::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct29() -> Struct29 {
+    Struct29Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct29() -> Struct29 {
+    Struct29 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -478,6 +1899,55 @@ pub struct Struct30 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct30() -> Struct30 {
+    Struct30::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct30() -> Struct30 {
+    Struct30Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct30() -> Struct30 {
+    Struct30 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -494,6 +1964,55 @@ pub struct Struct31 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct31() -> Struct31 {
+    Struct31::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct31() -> Struct31 {
+    Struct31Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct31() -> Struct31 {
+    Struct31 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -510,6 +2029,55 @@ pub struct Struct32 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct32() -> Struct32 {
+    Struct32::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct32() -> Struct32 {
+    Struct32Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct32() -> Struct32 {
+    Struct32 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -526,6 +2094,55 @@ pub struct Struct33 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct33() -> Struct33 {
+    Struct33::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct33() -> Struct33 {
+    Struct33Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct33() -> Struct33 {
+    Struct33 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -542,6 +2159,55 @@ pub struct Struct34 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct34() -> Struct34 {
+    Struct34::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct34() -> Struct34 {
+    Struct34Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct34() -> Struct34 {
+    Struct34 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -558,6 +2224,55 @@ pub struct Struct35 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct35() -> Struct35 {
+    Struct35::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct35() -> Struct35 {
+    Struct35Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct35() -> Struct35 {
+    Struct35 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -574,6 +2289,55 @@ pub struct Struct36 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct36() -> Struct36 {
+    Struct36::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct36() -> Struct36 {
+    Struct36Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct36() -> Struct36 {
+    Struct36 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -590,6 +2354,55 @@ pub struct Struct37 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct37() -> Struct37 {
+    Struct37::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct37() -> Struct37 {
+    Struct37Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct37() -> Struct37 {
+    Struct37 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -606,6 +2419,55 @@ pub struct Struct38 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct38() -> Struct38 {
+    Struct38::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct38() -> Struct38 {
+    Struct38Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct38() -> Struct38 {
+    Struct38 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -622,6 +2484,55 @@ pub struct Struct39 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct39() -> Struct39 {
+    Struct39::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct39() -> Struct39 {
+    Struct39Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct39() -> Struct39 {
+    Struct39 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -638,6 +2549,55 @@ pub struct Struct40 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct40() -> Struct40 {
+    Struct40::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct40() -> Struct40 {
+    Struct40Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct40() -> Struct40 {
+    Struct40 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -654,6 +2614,55 @@ pub struct Struct41 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct41() -> Struct41 {
+    Struct41::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct41() -> Struct41 {
+    Struct41Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct41() -> Struct41 {
+    Struct41 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -670,6 +2679,55 @@ pub struct Struct42 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct42() -> Struct42 {
+    Struct42::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct42() -> Struct42 {
+    Struct42Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct42() -> Struct42 {
+    Struct42 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -686,6 +2744,55 @@ pub struct Struct43 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct43() -> Struct43 {
+    Struct43::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct43() -> Struct43 {
+    Struct43Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct43() -> Struct43 {
+    Struct43 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -702,6 +2809,55 @@ pub struct Struct44 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct44() -> Struct44 {
+    Struct44::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct44() -> Struct44 {
+    Struct44Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct44() -> Struct44 {
+    Struct44 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -718,6 +2874,55 @@ pub struct Struct45 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct45() -> Struct45 {
+    Struct45::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct45() -> Struct45 {
+    Struct45Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct45() -> Struct45 {
+    Struct45 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -734,6 +2939,55 @@ pub struct Struct46 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct46() -> Struct46 {
+    Struct46::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct46() -> Struct46 {
+    Struct46Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct46() -> Struct46 {
+    Struct46 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -750,6 +3004,55 @@ pub struct Struct47 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct47() -> Struct47 {
+    Struct47::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct47() -> Struct47 {
+    Struct47Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct47() -> Struct47 {
+    Struct47 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -766,6 +3069,55 @@ pub struct Struct48 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct48() -> Struct48 {
+    Struct48::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct48() -> Struct48 {
+    Struct48Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct48() -> Struct48 {
+    Struct48 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -782,6 +3134,55 @@ pub struct Struct49 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct49() -> Struct49 {
+    Struct49::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct49() -> Struct49 {
+    Struct49Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct49() -> Struct49 {
+    Struct49 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -798,6 +3199,55 @@ pub struct Struct50 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct50() -> Struct50 {
+    Struct50::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct50() -> Struct50 {
+    Struct50Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct50() -> Struct50 {
+    Struct50 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -814,6 +3264,55 @@ pub struct Struct51 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct51() -> Struct51 {
+    Struct51::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct51() -> Struct51 {
+    Struct51Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct51() -> Struct51 {
+    Struct51 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -830,6 +3329,55 @@ pub struct Struct52 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct52() -> Struct52 {
+    Struct52::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct52() -> Struct52 {
+    Struct52Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct52() -> Struct52 {
+    Struct52 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -846,6 +3394,55 @@ pub struct Struct53 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct53() -> Struct53 {
+    Struct53::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct53() -> Struct53 {
+    Struct53Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct53() -> Struct53 {
+    Struct53 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -862,6 +3459,55 @@ pub struct Struct54 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct54() -> Struct54 {
+    Struct54::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct54() -> Struct54 {
+    Struct54Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct54() -> Struct54 {
+    Struct54 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -878,6 +3524,55 @@ pub struct Struct55 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct55() -> Struct55 {
+    Struct55::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct55() -> Struct55 {
+    Struct55Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct55() -> Struct55 {
+    Struct55 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -894,6 +3589,55 @@ pub struct Struct56 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct56() -> Struct56 {
+    Struct56::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct56() -> Struct56 {
+    Struct56Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct56() -> Struct56 {
+    Struct56 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -910,6 +3654,55 @@ pub struct Struct57 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct57() -> Struct57 {
+    Struct57::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct57() -> Struct57 {
+    Struct57Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct57() -> Struct57 {
+    Struct57 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -926,6 +3719,55 @@ pub struct Struct58 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct58() -> Struct58 {
+    Struct58::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct58() -> Struct58 {
+    Struct58Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct58() -> Struct58 {
+    Struct58 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -942,6 +3784,55 @@ pub struct Struct59 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct59() -> Struct59 {
+    Struct59::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct59() -> Struct59 {
+    Struct59Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct59() -> Struct59 {
+    Struct59 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -958,6 +3849,55 @@ pub struct Struct60 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct60() -> Struct60 {
+    Struct60::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct60() -> Struct60 {
+    Struct60Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct60() -> Struct60 {
+    Struct60 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -974,6 +3914,55 @@ pub struct Struct61 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct61() -> Struct61 {
+    Struct61::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct61() -> Struct61 {
+    Struct61Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct61() -> Struct61 {
+    Struct61 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -990,6 +3979,55 @@ pub struct Struct62 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct62() -> Struct62 {
+    Struct62::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct62() -> Struct62 {
+    Struct62Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct62() -> Struct62 {
+    Struct62 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1006,6 +4044,55 @@ pub struct Struct63 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct63() -> Struct63 {
+    Struct63::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct63() -> Struct63 {
+    Struct63Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct63() -> Struct63 {
+    Struct63 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1022,6 +4109,55 @@ pub struct Struct64 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct64() -> Struct64 {
+    Struct64::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct64() -> Struct64 {
+    Struct64Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct64() -> Struct64 {
+    Struct64 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1038,6 +4174,55 @@ pub struct Struct65 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct65() -> Struct65 {
+    Struct65::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct65() -> Struct65 {
+    Struct65Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct65() -> Struct65 {
+    Struct65 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1054,6 +4239,55 @@ pub struct Struct66 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct66() -> Struct66 {
+    Struct66::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct66() -> Struct66 {
+    Struct66Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct66() -> Struct66 {
+    Struct66 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1070,6 +4304,55 @@ pub struct Struct67 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct67() -> Struct67 {
+    Struct67::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct67() -> Struct67 {
+    Struct67Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct67() -> Struct67 {
+    Struct67 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1086,6 +4369,55 @@ pub struct Struct68 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct68() -> Struct68 {
+    Struct68::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct68() -> Struct68 {
+    Struct68Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct68() -> Struct68 {
+    Struct68 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1102,6 +4434,55 @@ pub struct Struct69 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct69() -> Struct69 {
+    Struct69::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct69() -> Struct69 {
+    Struct69Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct69() -> Struct69 {
+    Struct69 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1118,6 +4499,55 @@ pub struct Struct70 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct70() -> Struct70 {
+    Struct70::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct70() -> Struct70 {
+    Struct70Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct70() -> Struct70 {
+    Struct70 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1134,6 +4564,55 @@ pub struct Struct71 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct71() -> Struct71 {
+    Struct71::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct71() -> Struct71 {
+    Struct71Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct71() -> Struct71 {
+    Struct71 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1150,6 +4629,55 @@ pub struct Struct72 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct72() -> Struct72 {
+    Struct72::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct72() -> Struct72 {
+    Struct72Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct72() -> Struct72 {
+    Struct72 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1166,6 +4694,55 @@ pub struct Struct73 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct73() -> Struct73 {
+    Struct73::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct73() -> Struct73 {
+    Struct73Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct73() -> Struct73 {
+    Struct73 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1182,6 +4759,55 @@ pub struct Struct74 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct74() -> Struct74 {
+    Struct74::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct74() -> Struct74 {
+    Struct74Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct74() -> Struct74 {
+    Struct74 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1198,6 +4824,55 @@ pub struct Struct75 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct75() -> Struct75 {
+    Struct75::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct75() -> Struct75 {
+    Struct75Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct75() -> Struct75 {
+    Struct75 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1214,6 +4889,55 @@ pub struct Struct76 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct76() -> Struct76 {
+    Struct76::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct76() -> Struct76 {
+    Struct76Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct76() -> Struct76 {
+    Struct76 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1230,6 +4954,55 @@ pub struct Struct77 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct77() -> Struct77 {
+    Struct77::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct77() -> Struct77 {
+    Struct77Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct77() -> Struct77 {
+    Struct77 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1246,6 +5019,55 @@ pub struct Struct78 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct78() -> Struct78 {
+    Struct78::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct78() -> Struct78 {
+    Struct78Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct78() -> Struct78 {
+    Struct78 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1262,6 +5084,55 @@ pub struct Struct79 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct79() -> Struct79 {
+    Struct79::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct79() -> Struct79 {
+    Struct79Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct79() -> Struct79 {
+    Struct79 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1278,6 +5149,55 @@ pub struct Struct80 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct80() -> Struct80 {
+    Struct80::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct80() -> Struct80 {
+    Struct80Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct80() -> Struct80 {
+    Struct80 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1294,6 +5214,55 @@ pub struct Struct81 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct81() -> Struct81 {
+    Struct81::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct81() -> Struct81 {
+    Struct81Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct81() -> Struct81 {
+    Struct81 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1310,6 +5279,55 @@ pub struct Struct82 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct82() -> Struct82 {
+    Struct82::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct82() -> Struct82 {
+    Struct82Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct82() -> Struct82 {
+    Struct82 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1326,6 +5344,55 @@ pub struct Struct83 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct83() -> Struct83 {
+    Struct83::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct83() -> Struct83 {
+    Struct83Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct83() -> Struct83 {
+    Struct83 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1342,6 +5409,55 @@ pub struct Struct84 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct84() -> Struct84 {
+    Struct84::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct84() -> Struct84 {
+    Struct84Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct84() -> Struct84 {
+    Struct84 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1358,6 +5474,55 @@ pub struct Struct85 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct85() -> Struct85 {
+    Struct85::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct85() -> Struct85 {
+    Struct85Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct85() -> Struct85 {
+    Struct85 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1374,6 +5539,55 @@ pub struct Struct86 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct86() -> Struct86 {
+    Struct86::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct86() -> Struct86 {
+    Struct86Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct86() -> Struct86 {
+    Struct86 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1390,6 +5604,55 @@ pub struct Struct87 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct87() -> Struct87 {
+    Struct87::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct87() -> Struct87 {
+    Struct87Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct87() -> Struct87 {
+    Struct87 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1406,6 +5669,55 @@ pub struct Struct88 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct88() -> Struct88 {
+    Struct88::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct88() -> Struct88 {
+    Struct88Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct88() -> Struct88 {
+    Struct88 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1422,6 +5734,55 @@ pub struct Struct89 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct89() -> Struct89 {
+    Struct89::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct89() -> Struct89 {
+    Struct89Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct89() -> Struct89 {
+    Struct89 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1438,6 +5799,55 @@ pub struct Struct90 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct90() -> Struct90 {
+    Struct90::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct90() -> Struct90 {
+    Struct90Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct90() -> Struct90 {
+    Struct90 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1454,6 +5864,55 @@ pub struct Struct91 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct91() -> Struct91 {
+    Struct91::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct91() -> Struct91 {
+    Struct91Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct91() -> Struct91 {
+    Struct91 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1470,6 +5929,55 @@ pub struct Struct92 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct92() -> Struct92 {
+    Struct92::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct92() -> Struct92 {
+    Struct92Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct92() -> Struct92 {
+    Struct92 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1486,6 +5994,55 @@ pub struct Struct93 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct93() -> Struct93 {
+    Struct93::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct93() -> Struct93 {
+    Struct93Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct93() -> Struct93 {
+    Struct93 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1502,6 +6059,55 @@ pub struct Struct94 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct94() -> Struct94 {
+    Struct94::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct94() -> Struct94 {
+    Struct94Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct94() -> Struct94 {
+    Struct94 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1518,6 +6124,55 @@ pub struct Struct95 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct95() -> Struct95 {
+    Struct95::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct95() -> Struct95 {
+    Struct95Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct95() -> Struct95 {
+    Struct95 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1534,6 +6189,55 @@ pub struct Struct96 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct96() -> Struct96 {
+    Struct96::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct96() -> Struct96 {
+    Struct96Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct96() -> Struct96 {
+    Struct96 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1550,6 +6254,55 @@ pub struct Struct97 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct97() -> Struct97 {
+    Struct97::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct97() -> Struct97 {
+    Struct97Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct97() -> Struct97 {
+    Struct97 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1566,6 +6319,55 @@ pub struct Struct98 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct98() -> Struct98 {
+    Struct98::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct98() -> Struct98 {
+    Struct98Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct98() -> Struct98 {
+    Struct98 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1582,6 +6384,55 @@ pub struct Struct99 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct99() -> Struct99 {
+    Struct99::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct99() -> Struct99 {
+    Struct99Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct99() -> Struct99 {
+    Struct99 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -1598,3 +6449,52 @@ pub struct Struct100 {
     x9: i32,
     x10: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct100() -> Struct100 {
+    Struct100::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct100() -> Struct100 {
+    Struct100Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct100() -> Struct100 {
+    Struct100 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+    }
+}
diff --git a/benchmarks/compilation/src/structs_10_fields_50.rs b/benchmarks/compilation/src/structs_10_fields_50.rs
index e3026f62..e8b6d30f 100644
--- a/benchmarks/compilation/src/structs_10_fields_50.rs
+++ b/benchmarks/compilation/src/structs_10_fields_50.rs
@@ -54,6 +54,175 @@ pub struct Struct1 {
     x49: i32,
     x50: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct1() -> Struct1 {
+    Struct1::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct1() -> Struct1 {
+    Struct1Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct1() -> Struct1 {
+    Struct1 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+        x11: 11,
+        x12: 12,
+        x13: 13,
+        x14: 14,
+        x15: 15,
+        x16: 16,
+        x17: 17,
+        x18: 18,
+        x19: 19,
+        x20: 20,
+        x21: 21,
+        x22: 22,
+        x23: 23,
+        x24: 24,
+        x25: 25,
+        x26: 26,
+        x27: 27,
+        x28: 28,
+        x29: 29,
+        x30: 30,
+        x31: 31,
+        x32: 32,
+        x33: 33,
+        x34: 34,
+        x35: 35,
+        x36: 36,
+        x37: 37,
+        x38: 38,
+        x39: 39,
+        x40: 40,
+        x41: 41,
+        x42: 42,
+        x43: 43,
+        x44: 44,
+        x45: 45,
+        x46: 46,
+        x47: 47,
+        x48: 48,
+        x49: 49,
+        x50: 50,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -110,6 +279,175 @@ pub struct Struct2 {
     x49: i32,
     x50: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct2() -> Struct2 {
+    Struct2::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct2() -> Struct2 {
+    Struct2Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct2() -> Struct2 {
+    Struct2 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+        x11: 11,
+        x12: 12,
+        x13: 13,
+        x14: 14,
+        x15: 15,
+        x16: 16,
+        x17: 17,
+        x18: 18,
+        x19: 19,
+        x20: 20,
+        x21: 21,
+        x22: 22,
+        x23: 23,
+        x24: 24,
+        x25: 25,
+        x26: 26,
+        x27: 27,
+        x28: 28,
+        x29: 29,
+        x30: 30,
+        x31: 31,
+        x32: 32,
+        x33: 33,
+        x34: 34,
+        x35: 35,
+        x36: 36,
+        x37: 37,
+        x38: 38,
+        x39: 39,
+        x40: 40,
+        x41: 41,
+        x42: 42,
+        x43: 43,
+        x44: 44,
+        x45: 45,
+        x46: 46,
+        x47: 47,
+        x48: 48,
+        x49: 49,
+        x50: 50,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -166,6 +504,175 @@ pub struct Struct3 {
     x49: i32,
     x50: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct3() -> Struct3 {
+    Struct3::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct3() -> Struct3 {
+    Struct3Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct3() -> Struct3 {
+    Struct3 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+        x11: 11,
+        x12: 12,
+        x13: 13,
+        x14: 14,
+        x15: 15,
+        x16: 16,
+        x17: 17,
+        x18: 18,
+        x19: 19,
+        x20: 20,
+        x21: 21,
+        x22: 22,
+        x23: 23,
+        x24: 24,
+        x25: 25,
+        x26: 26,
+        x27: 27,
+        x28: 28,
+        x29: 29,
+        x30: 30,
+        x31: 31,
+        x32: 32,
+        x33: 33,
+        x34: 34,
+        x35: 35,
+        x36: 36,
+        x37: 37,
+        x38: 38,
+        x39: 39,
+        x40: 40,
+        x41: 41,
+        x42: 42,
+        x43: 43,
+        x44: 44,
+        x45: 45,
+        x46: 46,
+        x47: 47,
+        x48: 48,
+        x49: 49,
+        x50: 50,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -222,6 +729,175 @@ pub struct Struct4 {
     x49: i32,
     x50: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct4() -> Struct4 {
+    Struct4::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct4() -> Struct4 {
+    Struct4Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct4() -> Struct4 {
+    Struct4 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+        x11: 11,
+        x12: 12,
+        x13: 13,
+        x14: 14,
+        x15: 15,
+        x16: 16,
+        x17: 17,
+        x18: 18,
+        x19: 19,
+        x20: 20,
+        x21: 21,
+        x22: 22,
+        x23: 23,
+        x24: 24,
+        x25: 25,
+        x26: 26,
+        x27: 27,
+        x28: 28,
+        x29: 29,
+        x30: 30,
+        x31: 31,
+        x32: 32,
+        x33: 33,
+        x34: 34,
+        x35: 35,
+        x36: 36,
+        x37: 37,
+        x38: 38,
+        x39: 39,
+        x40: 40,
+        x41: 41,
+        x42: 42,
+        x43: 43,
+        x44: 44,
+        x45: 45,
+        x46: 46,
+        x47: 47,
+        x48: 48,
+        x49: 49,
+        x50: 50,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -278,6 +954,175 @@ pub struct Struct5 {
     x49: i32,
     x50: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct5() -> Struct5 {
+    Struct5::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct5() -> Struct5 {
+    Struct5Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct5() -> Struct5 {
+    Struct5 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+        x11: 11,
+        x12: 12,
+        x13: 13,
+        x14: 14,
+        x15: 15,
+        x16: 16,
+        x17: 17,
+        x18: 18,
+        x19: 19,
+        x20: 20,
+        x21: 21,
+        x22: 22,
+        x23: 23,
+        x24: 24,
+        x25: 25,
+        x26: 26,
+        x27: 27,
+        x28: 28,
+        x29: 29,
+        x30: 30,
+        x31: 31,
+        x32: 32,
+        x33: 33,
+        x34: 34,
+        x35: 35,
+        x36: 36,
+        x37: 37,
+        x38: 38,
+        x39: 39,
+        x40: 40,
+        x41: 41,
+        x42: 42,
+        x43: 43,
+        x44: 44,
+        x45: 45,
+        x46: 46,
+        x47: 47,
+        x48: 48,
+        x49: 49,
+        x50: 50,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -334,6 +1179,175 @@ pub struct Struct6 {
     x49: i32,
     x50: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct6() -> Struct6 {
+    Struct6::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct6() -> Struct6 {
+    Struct6Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct6() -> Struct6 {
+    Struct6 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+        x11: 11,
+        x12: 12,
+        x13: 13,
+        x14: 14,
+        x15: 15,
+        x16: 16,
+        x17: 17,
+        x18: 18,
+        x19: 19,
+        x20: 20,
+        x21: 21,
+        x22: 22,
+        x23: 23,
+        x24: 24,
+        x25: 25,
+        x26: 26,
+        x27: 27,
+        x28: 28,
+        x29: 29,
+        x30: 30,
+        x31: 31,
+        x32: 32,
+        x33: 33,
+        x34: 34,
+        x35: 35,
+        x36: 36,
+        x37: 37,
+        x38: 38,
+        x39: 39,
+        x40: 40,
+        x41: 41,
+        x42: 42,
+        x43: 43,
+        x44: 44,
+        x45: 45,
+        x46: 46,
+        x47: 47,
+        x48: 48,
+        x49: 49,
+        x50: 50,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -390,6 +1404,175 @@ pub struct Struct7 {
     x49: i32,
     x50: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct7() -> Struct7 {
+    Struct7::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct7() -> Struct7 {
+    Struct7Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct7() -> Struct7 {
+    Struct7 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+        x11: 11,
+        x12: 12,
+        x13: 13,
+        x14: 14,
+        x15: 15,
+        x16: 16,
+        x17: 17,
+        x18: 18,
+        x19: 19,
+        x20: 20,
+        x21: 21,
+        x22: 22,
+        x23: 23,
+        x24: 24,
+        x25: 25,
+        x26: 26,
+        x27: 27,
+        x28: 28,
+        x29: 29,
+        x30: 30,
+        x31: 31,
+        x32: 32,
+        x33: 33,
+        x34: 34,
+        x35: 35,
+        x36: 36,
+        x37: 37,
+        x38: 38,
+        x39: 39,
+        x40: 40,
+        x41: 41,
+        x42: 42,
+        x43: 43,
+        x44: 44,
+        x45: 45,
+        x46: 46,
+        x47: 47,
+        x48: 48,
+        x49: 49,
+        x50: 50,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -446,6 +1629,175 @@ pub struct Struct8 {
     x49: i32,
     x50: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct8() -> Struct8 {
+    Struct8::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct8() -> Struct8 {
+    Struct8Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct8() -> Struct8 {
+    Struct8 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+        x11: 11,
+        x12: 12,
+        x13: 13,
+        x14: 14,
+        x15: 15,
+        x16: 16,
+        x17: 17,
+        x18: 18,
+        x19: 19,
+        x20: 20,
+        x21: 21,
+        x22: 22,
+        x23: 23,
+        x24: 24,
+        x25: 25,
+        x26: 26,
+        x27: 27,
+        x28: 28,
+        x29: 29,
+        x30: 30,
+        x31: 31,
+        x32: 32,
+        x33: 33,
+        x34: 34,
+        x35: 35,
+        x36: 36,
+        x37: 37,
+        x38: 38,
+        x39: 39,
+        x40: 40,
+        x41: 41,
+        x42: 42,
+        x43: 43,
+        x44: 44,
+        x45: 45,
+        x46: 46,
+        x47: 47,
+        x48: 48,
+        x49: 49,
+        x50: 50,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -502,6 +1854,175 @@ pub struct Struct9 {
     x49: i32,
     x50: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct9() -> Struct9 {
+    Struct9::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct9() -> Struct9 {
+    Struct9Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct9() -> Struct9 {
+    Struct9 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+        x11: 11,
+        x12: 12,
+        x13: 13,
+        x14: 14,
+        x15: 15,
+        x16: 16,
+        x17: 17,
+        x18: 18,
+        x19: 19,
+        x20: 20,
+        x21: 21,
+        x22: 22,
+        x23: 23,
+        x24: 24,
+        x25: 25,
+        x26: 26,
+        x27: 27,
+        x28: 28,
+        x29: 29,
+        x30: 30,
+        x31: 31,
+        x32: 32,
+        x33: 33,
+        x34: 34,
+        x35: 35,
+        x36: 36,
+        x37: 37,
+        x38: 38,
+        x39: 39,
+        x40: 40,
+        x41: 41,
+        x42: 42,
+        x43: 43,
+        x44: 44,
+        x45: 45,
+        x46: 46,
+        x47: 47,
+        x48: 48,
+        x49: 49,
+        x50: 50,
+    }
+}
 #[cfg_attr(
     any(feature = "bon", feature = "typed-builder", feature = "derive_builder",),
     derive(crate::Builder)
@@ -558,3 +2079,172 @@ pub struct Struct10 {
     x49: i32,
     x50: i32,
 }
+#[cfg(any(feature = "bon", feature = "typed-builder"))]
+pub fn struct10() -> Struct10 {
+    Struct10::builder()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+}
+#[cfg(all(
+    feature = "derive_builder",
+    not(any(feature = "bon", feature = "typed-builder")),
+))]
+pub fn struct10() -> Struct10 {
+    Struct10Builder::default()
+        .x1(1)
+        .x2(2)
+        .x3(3)
+        .x4(4)
+        .x5(5)
+        .x6(6)
+        .x7(7)
+        .x8(8)
+        .x9(9)
+        .x10(10)
+        .x11(11)
+        .x12(12)
+        .x13(13)
+        .x14(14)
+        .x15(15)
+        .x16(16)
+        .x17(17)
+        .x18(18)
+        .x19(19)
+        .x20(20)
+        .x21(21)
+        .x22(22)
+        .x23(23)
+        .x24(24)
+        .x25(25)
+        .x26(26)
+        .x27(27)
+        .x28(28)
+        .x29(29)
+        .x30(30)
+        .x31(31)
+        .x32(32)
+        .x33(33)
+        .x34(34)
+        .x35(35)
+        .x36(36)
+        .x37(37)
+        .x38(38)
+        .x39(39)
+        .x40(40)
+        .x41(41)
+        .x42(42)
+        .x43(43)
+        .x44(44)
+        .x45(45)
+        .x46(46)
+        .x47(47)
+        .x48(48)
+        .x49(49)
+        .x50(50)
+        .build()
+        .unwrap()
+}
+#[cfg(not(any(feature = "bon", feature = "typed-builder", feature = "derive_builder",)))]
+pub fn struct10() -> Struct10 {
+    Struct10 {
+        x1: 1,
+        x2: 2,
+        x3: 3,
+        x4: 4,
+        x5: 5,
+        x6: 6,
+        x7: 7,
+        x8: 8,
+        x9: 9,
+        x10: 10,
+        x11: 11,
+        x12: 12,
+        x13: 13,
+        x14: 14,
+        x15: 15,
+        x16: 16,
+        x17: 17,
+        x18: 18,
+        x19: 19,
+        x20: 20,
+        x21: 21,
+        x22: 22,
+        x23: 23,
+        x24: 24,
+        x25: 25,
+        x26: 26,
+        x27: 27,
+        x28: 28,
+        x29: 29,
+        x30: 30,
+        x31: 31,
+        x32: 32,
+        x33: 33,
+        x34: 34,
+        x35: 35,
+        x36: 36,
+        x37: 37,
+        x38: 38,
+        x39: 39,
+        x40: 40,
+        x41: 41,
+        x42: 42,
+        x43: 43,
+        x44: 44,
+        x45: 45,
+        x46: 46,
+        x47: 47,
+        x48: 48,
+        x49: 49,
+        x50: 50,
+    }
+}
diff --git a/bon/tests/integration/ui/compile_fail/attr_bon.stderr b/bon/tests/integration/ui/compile_fail/attr_bon.stderr
index 5197cb41..5fcf62c8 100644
--- a/bon/tests/integration/ui/compile_fail/attr_bon.stderr
+++ b/bon/tests/integration/ui/compile_fail/attr_bon.stderr
@@ -85,7 +85,7 @@ error: `const` items in this context need a name
    |
    = note: this error originates in the attribute macro `bon::builder` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error[E0433]: cannot find `foo` in the crate root
+error[E0433]: cannot find `foo` in the list of imported crates
   --> tests/integration/ui/compile_fail/attr_bon.rs:35:9
    |
 35 |     #[::foo::builder]
diff --git a/bon/tests/integration/ui/compile_fail/attr_required.stderr b/bon/tests/integration/ui/compile_fail/attr_required.stderr
index 5df9778e..6172dd72 100644
--- a/bon/tests/integration/ui/compile_fail/attr_required.stderr
+++ b/bon/tests/integration/ui/compile_fail/attr_required.stderr
@@ -64,7 +64,8 @@ note: required for `sut_builder::Empty` to implement `sut_builder::IsComplete`
    |
 45 |         #[derive(Builder)]
    |                  ^^^^^^^ type parameter would need to implement `sut_builder::IsComplete`
-   = help: consider manually implementing `sut_builder::IsComplete` to avoid undesired bounds
+   = help: consider manually implementing `sut_builder::IsComplete` to avoid undesired bounds caused by "imperfect derives"
+   = note: to learn more, visit <https://github.com/rust-lang/rust/issues/26925>
 note: required by a bound in `SutBuilder::<S>::build`
   --> tests/integration/ui/compile_fail/attr_required.rs:45:18
    |
diff --git a/bon/tests/integration/ui/compile_fail/diagnostic_on_unimplemented.stderr b/bon/tests/integration/ui/compile_fail/diagnostic_on_unimplemented.stderr
index 7c483e1b..ddcc1955 100644
--- a/bon/tests/integration/ui/compile_fail/diagnostic_on_unimplemented.stderr
+++ b/bon/tests/integration/ui/compile_fail/diagnostic_on_unimplemented.stderr
@@ -10,7 +10,8 @@ note: required for `SetX` to implement `IsComplete`
    |
  4 |     #[derive(Builder)]
    |              ^^^^^^^ type parameter would need to implement `IsComplete`
-   = help: consider manually implementing `IsComplete` to avoid undesired bounds
+   = help: consider manually implementing `IsComplete` to avoid undesired bounds caused by "imperfect derives"
+   = note: to learn more, visit <https://github.com/rust-lang/rust/issues/26925>
 note: required by a bound in `ExampleBuilder::<S>::build`
   --> tests/integration/ui/compile_fail/diagnostic_on_unimplemented.rs:4:14
    |
@@ -32,7 +33,8 @@ note: required for `SetX` to implement `IsComplete`
    |
  4 |     #[derive(Builder)]
    |              ^^^^^^^ type parameter would need to implement `IsComplete`
-   = help: consider manually implementing `IsComplete` to avoid undesired bounds
+   = help: consider manually implementing `IsComplete` to avoid undesired bounds caused by "imperfect derives"
+   = note: to learn more, visit <https://github.com/rust-lang/rust/issues/26925>
 note: required by a bound in `ExampleBuilder::<S>::build`
   --> tests/integration/ui/compile_fail/diagnostic_on_unimplemented.rs:4:14
    |
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index 6cb8fe4d..af4a9b44 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,5 +1,5 @@
 [toolchain]
-channel = "1.98.0"
+channel = "1.99.0"
 # rust-src is required for consistently generating test snapshots with
 # `trybuild` that contain snippets of code from the standard library.
 components = ["cargo", "rust-src"]