diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..ac40f80
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,8 @@
+{
+  "rust-analyzer.linkedProjects": [
+    ".\\tuples\\Cargo.toml",
+    ".\\tuples\\Cargo.toml",
+    ".\\tuples\\Cargo.toml"
+  ],
+  "rust-analyzer.showUnlinkedFileNotification": false
+}
diff --git a/code_gen/src/code_gen.rs b/code_gen/src/code_gen.rs
index 135b662..4ecf177 100644
--- a/code_gen/src/code_gen.rs
+++ b/code_gen/src/code_gen.rs
@@ -30,6 +30,7 @@ pub fn code_gen(out_dir: &Path) {
     gen_cloned(&ctx, &out_dir);
     gen_call(&ctx, &out_dir);
     gen_apply_tuple(&ctx, &out_dir);
+    gen_capt(&ctx, &out_dir);
 }
 
 #[allow(dead_code)]
@@ -1275,6 +1276,15 @@ fn gen_apply_tuple_size(ctx: &Ctx, size: usize) -> TokenStream {
             type DynFnOnce = dyn FnOnce(#(#nts),*) -> R;
             type DynFnMut = dyn FnMut(#(#nts),*) -> R;
             type DynFn = dyn Fn(#(#nts),*) -> R;
+            type FnPtr = fn(#(#nts),*) -> R;
+        }
+
+        impl<F: FnOnce(#(#nts),*) -> R, R, #(#nts),*> ApplyTupleMeta<(#(#nts,)*)> for F {
+            type Output = R;
+            type DynFnOnce = dyn FnOnce(#(#nts),*) -> R;
+            type DynFnMut = dyn FnMut(#(#nts),*) -> R;
+            type DynFn = dyn Fn(#(#nts),*) -> R;
+            type FnPtr = fn(#(#nts),*) -> R;
         }
 
         impl<F: FnOnce(#(#nts),*) -> R, R, #(#nts),*> ApplyTupleOnce<(#(#nts,)*)> for F {
@@ -1299,3 +1309,38 @@ fn gen_apply_tuple_size(ctx: &Ctx, size: usize) -> TokenStream {
     };
     tks
 }
+
+fn gen_capt(ctx: &Ctx, out_dir: &Path) {
+    let items = (1..33usize).map(|i| gen_capt_size(ctx, i));
+    let tks = quote! { #(#items)* };
+    let mut code = tks.to_string();
+    code.insert_str(0, "// This file is by code gen, do not modify\n\n");
+    let dest_path = Path::new(out_dir).join("capt.rs");
+    fs::write(&dest_path, code).unwrap();
+}
+
+fn gen_capt_size(ctx: &Ctx, size: usize) -> TokenStream {
+    let nts = &ctx.nts[0..size];
+    let nvs = &ctx.nvs[0..size];
+    let name = format_ident!("capt_{}", size);
+    let name_mut = format_ident!("capt_mut_{}", size);
+    let name_once = format_ident!("capt_once_{}", size);
+    let tks = quote! {
+        #[doc = "Manually capture the variables required by the closure"]
+        pub fn #name<C, #(#nts),*, R, F: Fn(&C, #(#nts),*) -> R>(c: C, f: F) -> impl Fn(#(#nts),*) -> R {
+            move |#(#nvs,)*| f(&c, #(#nvs,)*)
+        }
+
+        #[doc = "Manually capture the variables required by the closure"]
+        pub fn #name_mut<C, #(#nts),*, R, F: FnMut(&mut C, #(#nts),*) -> R>(mut c: C, mut f: F) -> impl FnMut(#(#nts),*) -> R {
+            move |#(#nvs,)*| f(&mut c, #(#nvs,)*)
+        }
+
+        #[doc = "Manually capture the variables required by the closure"]
+        pub fn #name_once<C, #(#nts),*, R, F: FnOnce(C, #(#nts),*) -> R>(c: C, f: F) -> impl FnOnce(#(#nts),*) -> R {
+            move |#(#nvs,)*| f(c, #(#nvs,)*)
+        }
+
+    };
+    tks
+}
diff --git a/tuples/Cargo.toml b/tuples/Cargo.toml
index 84d3c66..abca385 100644
--- a/tuples/Cargo.toml
+++ b/tuples/Cargo.toml
@@ -8,7 +8,7 @@ license = "MIT"
 name = "tuples"
 readme = "../README.md"
 repository = "https://github.com/libsugar/tuplers"
-version = "1.11.0"
+version = "1.12.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -32,6 +32,7 @@ default = [
   "cloned",
   "tuple_call",
   "re-exports",
+  "capt",
 ]
 flatten = []
 re-exports = []
@@ -48,3 +49,4 @@ tuple_call = []
 tuple_iter = []
 tuple_map = []
 tuple_meta = []
+capt = []
diff --git a/tuples/src/apply_tuple.rs b/tuples/src/apply_tuple.rs
index 9a1cc5d..0d5c8ad 100644
--- a/tuples/src/apply_tuple.rs
+++ b/tuples/src/apply_tuple.rs
@@ -6,6 +6,16 @@ pub trait TupleFnMeta<R> {
     type DynFnOnce: ?Sized;
     type DynFnMut: ?Sized;
     type DynFn: ?Sized;
+    type FnPtr;
+}
+
+/// Apply tuple meta
+pub trait ApplyTupleMeta<Tuple> {
+    type Output;
+    type DynFnOnce: ?Sized;
+    type DynFnMut: ?Sized;
+    type DynFn: ?Sized;
+    type FnPtr;
 }
 
 /// Apply tuple as args to FnOnce
diff --git a/tuples/src/capt.rs b/tuples/src/capt.rs
index cba6eff..3787506 100644
--- a/tuples/src/capt.rs
+++ b/tuples/src/capt.rs
@@ -1,9 +1,44 @@
+//! Manually capture the variables required by the closure
+
 /// Manually capture the variables required by the closure
-pub fn capt0<T, R, F: Fn(&T) -> R>(v: T, f: F) -> impl Fn() -> R {
+pub fn capt_0<T, R, F: Fn(&T) -> R>(v: T, f: F) -> impl Fn() -> R {
     move || f(&v)
 }
 
 /// Manually capture the variables required by the closure
-pub fn capt1<T, A, R, F: Fn(&T, A) -> R>(v: T, f: F) -> impl Fn(A) -> R {
-    move |a| f(&v, a)
+pub fn capt_mut_0<T, R, F: FnMut(&mut T) -> R>(mut v: T, mut f: F) -> impl FnMut() -> R {
+    move || f(&mut v)
+}
+
+/// Manually capture the variables required by the closure
+pub fn capt_once_0<T, R, F: FnOnce(T) -> R>(v: T, f: F) -> impl FnOnce() -> R {
+    move || f(v)
+}
+
+include!("./gen/capt.rs");
+
+#[test]
+fn test1() {
+    let a = capt_0(1, |a| *a);
+    let r = a();
+    assert_eq!(r, 1);
+}
+
+#[test]
+fn test2() {
+    let a = capt_1(2, |a, b| *a * b);
+    let r = a(3);
+    assert_eq!(r, 6);
+}
+
+#[test]
+fn test3() {
+    let mut a = capt_mut_1(2, |a, b| {
+        *a *= b;
+        *a
+    });
+    let r = a(3);
+    assert_eq!(r, 6);
+    let r = a(3);
+    assert_eq!(r, 18);
 }
diff --git a/tuples/src/gen/apply_tuple.rs b/tuples/src/gen/apply_tuple.rs
index c2c873d..0ab91f2 100644
--- a/tuples/src/gen/apply_tuple.rs
+++ b/tuples/src/gen/apply_tuple.rs
@@ -5,6 +5,14 @@ impl<R> TupleFnMeta<R> for () {
     type DynFnOnce = dyn FnOnce() -> R;
     type DynFnMut = dyn FnMut() -> R;
     type DynFn = dyn Fn() -> R;
+    type FnPtr = fn() -> R;
+}
+impl<F: FnOnce() -> R, R> ApplyTupleMeta<()> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce() -> R;
+    type DynFnMut = dyn FnMut() -> R;
+    type DynFn = dyn Fn() -> R;
+    type FnPtr = fn() -> R;
 }
 impl<F: FnOnce() -> R, R> ApplyTupleOnce<()> for F {
     type Output = R;
@@ -27,6 +35,14 @@ impl<R, T0> TupleFnMeta<R> for (T0,) {
     type DynFnOnce = dyn FnOnce(T0) -> R;
     type DynFnMut = dyn FnMut(T0) -> R;
     type DynFn = dyn Fn(T0) -> R;
+    type FnPtr = fn(T0) -> R;
+}
+impl<F: FnOnce(T0) -> R, R, T0> ApplyTupleMeta<(T0,)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0) -> R;
+    type DynFnMut = dyn FnMut(T0) -> R;
+    type DynFn = dyn Fn(T0) -> R;
+    type FnPtr = fn(T0) -> R;
 }
 impl<F: FnOnce(T0) -> R, R, T0> ApplyTupleOnce<(T0,)> for F {
     type Output = R;
@@ -49,6 +65,14 @@ impl<R, T0, T1> TupleFnMeta<R> for (T0, T1) {
     type DynFnOnce = dyn FnOnce(T0, T1) -> R;
     type DynFnMut = dyn FnMut(T0, T1) -> R;
     type DynFn = dyn Fn(T0, T1) -> R;
+    type FnPtr = fn(T0, T1) -> R;
+}
+impl<F: FnOnce(T0, T1) -> R, R, T0, T1> ApplyTupleMeta<(T0, T1)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1) -> R;
+    type DynFnMut = dyn FnMut(T0, T1) -> R;
+    type DynFn = dyn Fn(T0, T1) -> R;
+    type FnPtr = fn(T0, T1) -> R;
 }
 impl<F: FnOnce(T0, T1) -> R, R, T0, T1> ApplyTupleOnce<(T0, T1)> for F {
     type Output = R;
@@ -71,6 +95,14 @@ impl<R, T0, T1, T2> TupleFnMeta<R> for (T0, T1, T2) {
     type DynFnOnce = dyn FnOnce(T0, T1, T2) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2) -> R;
     type DynFn = dyn Fn(T0, T1, T2) -> R;
+    type FnPtr = fn(T0, T1, T2) -> R;
+}
+impl<F: FnOnce(T0, T1, T2) -> R, R, T0, T1, T2> ApplyTupleMeta<(T0, T1, T2)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2) -> R;
+    type DynFn = dyn Fn(T0, T1, T2) -> R;
+    type FnPtr = fn(T0, T1, T2) -> R;
 }
 impl<F: FnOnce(T0, T1, T2) -> R, R, T0, T1, T2> ApplyTupleOnce<(T0, T1, T2)> for F {
     type Output = R;
@@ -93,6 +125,14 @@ impl<R, T0, T1, T2, T3> TupleFnMeta<R> for (T0, T1, T2, T3) {
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3) -> R;
+    type FnPtr = fn(T0, T1, T2, T3) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3) -> R, R, T0, T1, T2, T3> ApplyTupleMeta<(T0, T1, T2, T3)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3) -> R;
+    type FnPtr = fn(T0, T1, T2, T3) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3) -> R, R, T0, T1, T2, T3> ApplyTupleOnce<(T0, T1, T2, T3)> for F {
     type Output = R;
@@ -115,6 +155,14 @@ impl<R, T0, T1, T2, T3, T4> TupleFnMeta<R> for (T0, T1, T2, T3, T4) {
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4) -> R, R, T0, T1, T2, T3, T4> ApplyTupleMeta<(T0, T1, T2, T3, T4)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4) -> R, R, T0, T1, T2, T3, T4> ApplyTupleOnce<(T0, T1, T2, T3, T4)> for F {
     type Output = R;
@@ -137,6 +185,14 @@ impl<R, T0, T1, T2, T3, T4, T5> TupleFnMeta<R> for (T0, T1, T2, T3, T4, T5) {
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5) -> R, R, T0, T1, T2, T3, T4, T5> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5) -> R, R, T0, T1, T2, T3, T4, T5> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5)> for F {
     type Output = R;
@@ -159,6 +215,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6> TupleFnMeta<R> for (T0, T1, T2, T3, T4, T5,
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6) -> R, R, T0, T1, T2, T3, T4, T5, T6> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6) -> R, R, T0, T1, T2, T3, T4, T5, T6> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6)> for F {
     type Output = R;
@@ -181,6 +245,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7> TupleFnMeta<R> for (T0, T1, T2, T3, T4,
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7)> for F {
     type Output = R;
@@ -203,6 +275,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> TupleFnMeta<R> for (T0, T1, T2, T3,
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8)> for F {
     type Output = R;
@@ -225,6 +305,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> TupleFnMeta<R> for (T0, T1, T2,
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)> for F {
     type Output = R;
@@ -247,6 +335,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> TupleFnMeta<R> for (T0, T1,
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)> for F {
     type Output = R;
@@ -269,6 +365,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> TupleFnMeta<R> for (T0
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)> for F {
     type Output = R;
@@ -291,6 +395,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> TupleFnMeta<R> fo
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)> for F {
     type Output = R;
@@ -313,6 +425,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> TupleFnMeta<
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)> for F {
     type Output = R;
@@ -335,6 +455,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> TupleFn
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)> for F {
     type Output = R;
@@ -357,6 +485,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Tu
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)> for F {
     type Output = R;
@@ -379,6 +515,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)> for F {
     type Output = R;
@@ -401,6 +545,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)> for F {
     type Output = R;
@@ -423,6 +575,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)> for F {
     type Output = R;
@@ -445,6 +605,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)> for F {
     type Output = R;
@@ -467,6 +635,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)> for F {
     type Output = R;
@@ -489,6 +665,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)> for F {
     type Output = R;
@@ -511,6 +695,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)> for F {
     type Output = R;
@@ -533,6 +725,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)> for F {
     type Output = R;
@@ -555,6 +755,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)> for F {
     type Output = R;
@@ -577,6 +785,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)> for F {
     type Output = R;
@@ -599,6 +815,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)> for F {
     type Output = R;
@@ -621,6 +845,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)> for F {
     type Output = R;
@@ -643,6 +875,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)> for F {
     type Output = R;
@@ -665,6 +905,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)> for F {
     type Output = R;
@@ -687,6 +935,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)> for F {
     type Output = R;
@@ -709,6 +965,14 @@ impl<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
     type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R;
     type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R;
     type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R;
+}
+impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31> ApplyTupleMeta<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)> for F {
+    type Output = R;
+    type DynFnOnce = dyn FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R;
+    type DynFnMut = dyn FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R;
+    type DynFn = dyn Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R;
+    type FnPtr = fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R;
 }
 impl<F: FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R, R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31> ApplyTupleOnce<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)> for F {
     type Output = R;
diff --git a/tuples/src/gen/capt.rs b/tuples/src/gen/capt.rs
new file mode 100644
index 0000000..7e34aa5
--- /dev/null
+++ b/tuples/src/gen/capt.rs
@@ -0,0 +1,386 @@
+// This file is by code gen, do not modify
+
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_1<C, T0, R, F: Fn(&C, T0) -> R>(c: C, f: F) -> impl Fn(T0) -> R {
+    move |v0| f(&c, v0)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_1<C, T0, R, F: FnMut(&mut C, T0) -> R>(mut c: C, mut f: F) -> impl FnMut(T0) -> R {
+    move |v0| f(&mut c, v0)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_1<C, T0, R, F: FnOnce(C, T0) -> R>(c: C, f: F) -> impl FnOnce(T0) -> R {
+    move |v0| f(c, v0)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_2<C, T0, T1, R, F: Fn(&C, T0, T1) -> R>(c: C, f: F) -> impl Fn(T0, T1) -> R {
+    move |v0, v1| f(&c, v0, v1)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_2<C, T0, T1, R, F: FnMut(&mut C, T0, T1) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1) -> R {
+    move |v0, v1| f(&mut c, v0, v1)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_2<C, T0, T1, R, F: FnOnce(C, T0, T1) -> R>(c: C, f: F) -> impl FnOnce(T0, T1) -> R {
+    move |v0, v1| f(c, v0, v1)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_3<C, T0, T1, T2, R, F: Fn(&C, T0, T1, T2) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2) -> R {
+    move |v0, v1, v2| f(&c, v0, v1, v2)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_3<C, T0, T1, T2, R, F: FnMut(&mut C, T0, T1, T2) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2) -> R {
+    move |v0, v1, v2| f(&mut c, v0, v1, v2)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_3<C, T0, T1, T2, R, F: FnOnce(C, T0, T1, T2) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2) -> R {
+    move |v0, v1, v2| f(c, v0, v1, v2)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_4<C, T0, T1, T2, T3, R, F: Fn(&C, T0, T1, T2, T3) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3) -> R {
+    move |v0, v1, v2, v3| f(&c, v0, v1, v2, v3)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_4<C, T0, T1, T2, T3, R, F: FnMut(&mut C, T0, T1, T2, T3) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3) -> R {
+    move |v0, v1, v2, v3| f(&mut c, v0, v1, v2, v3)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_4<C, T0, T1, T2, T3, R, F: FnOnce(C, T0, T1, T2, T3) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3) -> R {
+    move |v0, v1, v2, v3| f(c, v0, v1, v2, v3)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_5<C, T0, T1, T2, T3, T4, R, F: Fn(&C, T0, T1, T2, T3, T4) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4) -> R {
+    move |v0, v1, v2, v3, v4| f(&c, v0, v1, v2, v3, v4)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_5<C, T0, T1, T2, T3, T4, R, F: FnMut(&mut C, T0, T1, T2, T3, T4) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4) -> R {
+    move |v0, v1, v2, v3, v4| f(&mut c, v0, v1, v2, v3, v4)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_5<C, T0, T1, T2, T3, T4, R, F: FnOnce(C, T0, T1, T2, T3, T4) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4) -> R {
+    move |v0, v1, v2, v3, v4| f(c, v0, v1, v2, v3, v4)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_6<C, T0, T1, T2, T3, T4, T5, R, F: Fn(&C, T0, T1, T2, T3, T4, T5) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5) -> R {
+    move |v0, v1, v2, v3, v4, v5| f(&c, v0, v1, v2, v3, v4, v5)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_6<C, T0, T1, T2, T3, T4, T5, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5) -> R {
+    move |v0, v1, v2, v3, v4, v5| f(&mut c, v0, v1, v2, v3, v4, v5)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_6<C, T0, T1, T2, T3, T4, T5, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5) -> R {
+    move |v0, v1, v2, v3, v4, v5| f(c, v0, v1, v2, v3, v4, v5)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_7<C, T0, T1, T2, T3, T4, T5, T6, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6| f(&c, v0, v1, v2, v3, v4, v5, v6)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_7<C, T0, T1, T2, T3, T4, T5, T6, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6| f(&mut c, v0, v1, v2, v3, v4, v5, v6)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_7<C, T0, T1, T2, T3, T4, T5, T6, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6| f(c, v0, v1, v2, v3, v4, v5, v6)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_8<C, T0, T1, T2, T3, T4, T5, T6, T7, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7| f(&c, v0, v1, v2, v3, v4, v5, v6, v7)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_8<C, T0, T1, T2, T3, T4, T5, T6, T7, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_8<C, T0, T1, T2, T3, T4, T5, T6, T7, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7| f(c, v0, v1, v2, v3, v4, v5, v6, v7)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_9<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_9<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_9<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_10<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_10<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_10<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_11<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_11<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_11<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_12<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_12<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_12<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_13<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_13<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_13<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_14<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_14<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_14<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_15<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_15<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_15<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_16<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_16<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_16<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_17<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_17<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_17<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_18<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_18<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_18<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_19<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_19<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_19<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_20<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_20<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_20<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_21<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_21<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_21<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_22<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_22<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_22<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_23<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_23<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_23<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_24<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_24<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_24<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_25<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_25<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_25<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_26<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_26<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_26<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_27<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_27<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_27<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_28<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_28<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_28<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_29<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_29<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_29<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_30<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_30<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_30<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_31<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_31<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_31<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_32<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, R, F: Fn(&C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R>(c: C, f: F) -> impl Fn(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31| f(&c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_mut_32<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, R, F: FnMut(&mut C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R>(mut c: C, mut f: F) -> impl FnMut(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31| f(&mut c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
+}
+#[doc = "Manually capture the variables required by the closure"]
+pub fn capt_once_32<C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, R, F: FnOnce(C, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R>(c: C, f: F) -> impl FnOnce(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) -> R {
+    move |v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31| f(c, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
+}
diff --git a/tuples/src/lib.rs b/tuples/src/lib.rs
index 3ecb0b6..6ab5119 100644
--- a/tuples/src/lib.rs
+++ b/tuples/src/lib.rs
@@ -185,3 +185,8 @@ pub use tuple_call::*;
 pub mod apply_tuple;
 #[cfg(all(feature = "apply_tuple", feature = "re-exports"))]
 pub use apply_tuple::*;
+
+#[cfg(feature = "capt")]
+pub mod capt;
+#[cfg(all(feature = "capt", feature = "re-exports"))]
+pub use capt::*;