diff --git a/src/middle/UnsizedType.ml b/src/middle/UnsizedType.ml
index a1f1960246..5e5f2f381f 100644
--- a/src/middle/UnsizedType.ml
+++ b/src/middle/UnsizedType.ml
@@ -150,6 +150,14 @@ let is_eigen_type ut =
 
 let is_fun_type = function UFun _ | UMathLibraryFunction -> true | _ -> false
 
+let rec contains_int ut =
+  match ut with
+  | UFun (_, Void, _, _)
+   |UReal | UComplex | UVector | URowVector | UMatrix | UMathLibraryFunction ->
+      false
+  | UInt -> true
+  | UArray x | UFun (_, ReturnType x, _, _) -> contains_int x
+
 let rec is_indexing_matrix = function
   | UArray t, _ :: idcs -> is_indexing_matrix (t, idcs)
   | UMatrix, [] -> false
diff --git a/src/stan_math_backend/Stan_math_code_gen.ml b/src/stan_math_backend/Stan_math_code_gen.ml
index ccec9f0133..3d9668cb67 100644
--- a/src/stan_math_backend/Stan_math_code_gen.ml
+++ b/src/stan_math_backend/Stan_math_code_gen.ml
@@ -54,7 +54,8 @@ let pp_located ppf _ =
     {|stan::lang::rethrow_located(e, locations_array__[current_statement__]);|}
 
 (** Detect if argument requires C++ template *)
-let arg_needs_template = function
+let arg_needs_template arg =
+  match arg with
   | UnsizedType.DataOnly, _, t -> UnsizedType.is_eigen_type t
   | _, _, t when UnsizedType.is_int_type t -> false
   | _ -> true
@@ -64,22 +65,23 @@ let arg_needs_template = function
   @return A list of arguments with template parameter names added.
  *)
 let maybe_templated_arg_types (args : Program.fun_arg_decl) =
-  List.mapi args ~f:(fun i a ->
-      match arg_needs_template a with
-      | true -> Some (sprintf "T%d__" i)
-      | false -> None )
+  List.mapi args ~f:(fun i (adtype, _, ut) ->
+      match ut with
+      | UMatrix | UVector | URowVector -> Some [sprintf "T%d__" i]
+      | (UReal | UComplex) when adtype = AutoDiffable -> Some [sprintf "T%d__" i]
+      | UArray _ -> Some [sprintf "T%d__" i; sprintf "Alloc%d__" i]
+      | UInt | UReal | UComplex | UMathLibraryFunction | UFun _ -> None )
 
 let return_arg_types (args : Program.fun_arg_decl) =
   List.mapi args ~f:(fun i ((_, _, ut) as a) ->
-      if UnsizedType.is_eigen_type ut && arg_needs_template a then
-        Some (sprintf "stan::value_type_t<T%d__>" i)
+      if not (UnsizedType.is_scalar_type ut) then Some (sprintf "T%d__" i)
       else if arg_needs_template a then Some (sprintf "T%d__" i)
       else None )
 
 let%expect_test "arg types templated correctly" =
   [(AutoDiffable, "xreal", UReal); (DataOnly, "yint", UInt)]
-  |> maybe_templated_arg_types |> List.filter_opt |> String.concat ~sep:","
-  |> print_endline ;
+  |> maybe_templated_arg_types |> List.filter_opt |> List.concat
+  |> String.concat ~sep:"," |> print_endline ;
   [%expect {| T0__ |}]
 
 (** Print the code for promoting stan real types
@@ -90,27 +92,24 @@ let pp_promoted_scalar ppf args =
   match args with
   | [] -> pf ppf "double"
   | _ ->
-      let rec promote_args_chunked ppf args =
-        let go ppf tl =
-          match tl with [] -> () | _ -> pf ppf ", %a" promote_args_chunked tl
-        in
-        match args with
-        | [] -> pf ppf "double"
-        | hd :: tl ->
-            pf ppf "stan::promote_args_t<%a%a>" (list ~sep:comma string) hd go
-              tl in
-      promote_args_chunked ppf
-        List.(chunks_of ~length:5 (filter_opt (return_arg_types args)))
+      let blah init xx =
+        match xx with
+        | Some x when init <> "" -> String.concat ~sep:", " [init; x]
+        | Some x -> String.concat ~sep:", " [x]
+        | None -> init in
+      pf ppf "stan::return_type_t<%s>"
+        (List.fold ~init:"" ~f:blah (return_arg_types args))
 
 (** Pretty-prints a function's return-type, taking into account templated argument
     promotion.*)
 let pp_returntype ppf arg_types rt =
   let scalar = str "%a" pp_promoted_scalar arg_types in
   match rt with
-  | Some ut when UnsizedType.is_int_type ut ->
-      pf ppf "%a@," pp_unsizedtype_custom_scalar ("int", ut)
-  | Some ut -> pf ppf "%a@," pp_unsizedtype_custom_scalar (scalar, ut)
-  | None -> pf ppf "void@,"
+  | Some ut when UnsizedType.contains_int ut ->
+      pf ppf "inline %a@," pp_unsizedtype_custom_scalar ("int", ut)
+  | Some ut when UnsizedType.is_scalar_type ut -> pf ppf "inline auto@,"
+  | Some ut -> pf ppf "inline %a@," pp_unsizedtype_custom_scalar (scalar, ut)
+  | None -> pf ppf "inline void@,"
 
 let pp_eigen_arg_to_ref ppf arg_types =
   let pp_ref ppf name =
@@ -133,6 +132,22 @@ let pp_located_error ppf (pp_body_block, body) =
   string ppf " catch (const std::exception& e) " ;
   pp_block ppf (pp_located, ())
 
+(**
+ * Print the types used in the C++ function signature.
+ * For most types we'll simply use the template typename given 
+ * such as `T{id}__, but for std::vector's we will specialize
+ * the function by wrapping the joint template parameters
+ * (`T{id}__, Alloc{id}__`) around `std::vector<{Templates}>.
+ *)
+let pp_arg_types ppf (scalar, ut) =
+  match ut with
+  | UnsizedType.UInt | UReal | UComplex | UMatrix | URowVector | UVector ->
+      string ppf scalar
+  | UArray _ ->
+      (* Expressions are not accepted for arrays of Eigen::Matrix *)
+      pf ppf "std::vector<%s>" scalar
+  | x -> raise_s [%message (x : UnsizedType.t) "not implemented yet"]
+
 (** Print the type of an object.
  @param ppf A pretty printer
  @param custom_scalar_opt A string representing a types inner scalar value.
@@ -145,8 +160,7 @@ let pp_arg ppf (custom_scalar_opt, (_, name, ut)) =
     | Some scalar -> scalar
     | None -> stantype_prim_str ut in
   (* we add the _arg suffix for any Eigen types *)
-  pf ppf "const %a& %s" pp_unsizedtype_custom_scalar_eigen_exprs (scalar, ut)
-    name
+  pf ppf "const %a& %s" pp_arg_types (scalar, ut) name
 
 let pp_arg_eigen_suffix ppf (custom_scalar_opt, (_, name, ut)) =
   let scalar =
@@ -156,8 +170,7 @@ let pp_arg_eigen_suffix ppf (custom_scalar_opt, (_, name, ut)) =
   (* we add the _arg suffix for any Eigen types *)
   let opt_arg_suffix =
     if UnsizedType.is_eigen_type ut then name ^ "_arg__" else name in
-  pf ppf "const %a& %s" pp_unsizedtype_custom_scalar_eigen_exprs (scalar, ut)
-    opt_arg_suffix
+  pf ppf "const %a& %s" pp_arg_types (scalar, ut) opt_arg_suffix
 
 (** [pp_located_error_b] automatically adds a Block wrapper *)
 let pp_located_error_b ppf body_stmts =
@@ -171,16 +184,17 @@ let typename = ( ^ ) "typename "
  @param fdargs A sexp list of strings representing C++ types.
   *)
 let get_templates_and_args exprs fdargs =
-  let argtypetemplates = maybe_templated_arg_types fdargs in
-  ( List.filter_opt argtypetemplates
+  let argtype_templates = maybe_templated_arg_types fdargs in
+  let templates =
+    List.map ~f:(Option.map ~f:(String.concat ~sep:", ")) argtype_templates
+  in
+  ( List.concat (List.filter_opt argtype_templates)
   , if not exprs then
-      List.map
-        ~f:(fun a -> str "%a" pp_arg a)
-        (List.zip_exn argtypetemplates fdargs)
+      List.map ~f:(fun a -> strf "%a" pp_arg a) (List.zip_exn templates fdargs)
     else
       List.map
-        ~f:(fun a -> str "%a" pp_arg_eigen_suffix a)
-        (List.zip_exn argtypetemplates fdargs) )
+        ~f:(fun a -> strf "%a" pp_arg_eigen_suffix a)
+        (List.zip_exn templates fdargs) )
 
 (** Print the C++ template parameter decleration before a function.
   @param ppf A pretty printer.
diff --git a/test/integration/good/code-gen/cpp.expected b/test/integration/good/code-gen/cpp.expected
index 12f12944fe..873cf16494 100644
--- a/test/integration/good/code-gen/cpp.expected
+++ b/test/integration/good/code-gen/cpp.expected
@@ -1273,7 +1273,7 @@ static constexpr std::array<const char*, 427> locations_array__ =
  " (in 'complex_scalar.stan', line 33, column 45 to line 35, column 3)"};
 
 
-std::complex<double>
+inline std::complex<double>
 foo(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -1291,7 +1291,7 @@ foo(std::ostream* pstream__) {
 }
 
 struct foo_functor__ {
-std::complex<double>
+inline std::complex<double>
 operator()(std::ostream* pstream__)  const 
 {
 return foo(pstream__);
@@ -1299,9 +1299,9 @@ return foo(pstream__);
 };
 
 template <typename T0__>
-stan::promote_args_t<T0__>
-foo1(const std::complex<T0__>& z, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+inline auto
+foo1(const T0__& z, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -1318,17 +1318,17 @@ foo1(const std::complex<T0__>& z, std::ostream* pstream__) {
 
 struct foo1_functor__ {
 template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::complex<T0__>& z, std::ostream* pstream__)  const 
+inline auto
+operator()(const T0__& z, std::ostream* pstream__)  const 
 {
 return foo1(z, pstream__);
 }
 };
 
 template <typename T0__>
-std::complex<stan::promote_args_t<T0__>>
+inline std::complex<stan::return_type_t<T0__>>
 foo2(const T0__& r, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -1345,7 +1345,7 @@ foo2(const T0__& r, std::ostream* pstream__) {
 
 struct foo2_functor__ {
 template <typename T0__>
-std::complex<stan::promote_args_t<T0__>>
+inline std::complex<stan::return_type_t<T0__>>
 operator()(const T0__& r, std::ostream* pstream__)  const 
 {
 return foo2(r, pstream__);
@@ -1353,9 +1353,9 @@ return foo2(r, pstream__);
 };
 
 template <typename T0__>
-std::complex<stan::promote_args_t<T0__>>
-foo3(const std::complex<T0__>& z, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+inline std::complex<stan::return_type_t<T0__>>
+foo3(const T0__& z, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -1372,14 +1372,14 @@ foo3(const std::complex<T0__>& z, std::ostream* pstream__) {
 
 struct foo3_functor__ {
 template <typename T0__>
-std::complex<stan::promote_args_t<T0__>>
-operator()(const std::complex<T0__>& z, std::ostream* pstream__)  const 
+inline std::complex<stan::return_type_t<T0__>>
+operator()(const T0__& z, std::ostream* pstream__)  const 
 {
 return foo3(z, pstream__);
 }
 };
 
-std::vector<std::complex<double>>
+inline std::vector<std::complex<double>>
 foo4(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -1397,17 +1397,17 @@ foo4(std::ostream* pstream__) {
 }
 
 struct foo4_functor__ {
-std::vector<std::complex<double>>
+inline std::vector<std::complex<double>>
 operator()(std::ostream* pstream__)  const 
 {
 return foo4(pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-foo5(const std::vector<std::complex<T0__>>& z, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+foo5(const std::vector<T0__, Alloc0__>& z, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -1423,18 +1423,18 @@ foo5(const std::vector<std::complex<T0__>>& z, std::ostream* pstream__) {
 }
 
 struct foo5_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::complex<T0__>>& z, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& z, std::ostream* pstream__)  const 
 {
 return foo5(z, pstream__);
 }
 };
 
 template <typename T0__>
-std::vector<std::complex<stan::promote_args_t<T0__>>>
+inline std::vector<std::complex<stan::return_type_t<T0__>>>
 foo6(const T0__& r, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -1452,17 +1452,17 @@ foo6(const T0__& r, std::ostream* pstream__) {
 
 struct foo6_functor__ {
 template <typename T0__>
-std::vector<std::complex<stan::promote_args_t<T0__>>>
+inline std::vector<std::complex<stan::return_type_t<T0__>>>
 operator()(const T0__& r, std::ostream* pstream__)  const 
 {
 return foo6(r, pstream__);
 }
 };
 
-template <typename T0__>
-std::vector<std::complex<stan::promote_args_t<T0__>>>
-foo7(const std::vector<std::complex<T0__>>& z, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline std::vector<std::complex<stan::return_type_t<T0__>>>
+foo7(const std::vector<T0__, Alloc0__>& z, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -1478,19 +1478,18 @@ foo7(const std::vector<std::complex<T0__>>& z, std::ostream* pstream__) {
 }
 
 struct foo7_functor__ {
-template <typename T0__>
-std::vector<std::complex<stan::promote_args_t<T0__>>>
-operator()(const std::vector<std::complex<T0__>>& z, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline std::vector<std::complex<stan::return_type_t<T0__>>>
+operator()(const std::vector<T0__, Alloc0__>& z, std::ostream* pstream__)  const 
 {
 return foo7(z, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-foo8(const std::vector<std::vector<std::complex<T0__>>>& z,
-     std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+foo8(const std::vector<T0__, Alloc0__>& z, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -1506,19 +1505,18 @@ foo8(const std::vector<std::vector<std::complex<T0__>>>& z,
 }
 
 struct foo8_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<std::complex<T0__>>>& z,
-           std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& z, std::ostream* pstream__)  const 
 {
 return foo8(z, pstream__);
 }
 };
 
 template <typename T0__>
-std::vector<std::vector<std::complex<stan::promote_args_t<T0__>>>>
+inline std::vector<std::vector<std::complex<stan::return_type_t<T0__>>>>
 foo9(const T0__& r, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -1539,18 +1537,17 @@ foo9(const T0__& r, std::ostream* pstream__) {
 
 struct foo9_functor__ {
 template <typename T0__>
-std::vector<std::vector<std::complex<stan::promote_args_t<T0__>>>>
+inline std::vector<std::vector<std::complex<stan::return_type_t<T0__>>>>
 operator()(const T0__& r, std::ostream* pstream__)  const 
 {
 return foo9(r, pstream__);
 }
 };
 
-template <typename T0__>
-std::vector<std::vector<std::complex<stan::promote_args_t<T0__>>>>
-foo10(const std::vector<std::vector<std::complex<T0__>>>& z,
-      std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline std::vector<std::vector<std::complex<stan::return_type_t<T0__>>>>
+foo10(const std::vector<T0__, Alloc0__>& z, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -1566,10 +1563,9 @@ foo10(const std::vector<std::vector<std::complex<T0__>>>& z,
 }
 
 struct foo10_functor__ {
-template <typename T0__>
-std::vector<std::vector<std::complex<stan::promote_args_t<T0__>>>>
-operator()(const std::vector<std::vector<std::complex<T0__>>>& z,
-           std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline std::vector<std::vector<std::complex<stan::return_type_t<T0__>>>>
+operator()(const std::vector<T0__, Alloc0__>& z, std::ostream* pstream__)  const 
 {
 return foo10(z, pstream__);
 }
@@ -4011,9 +4007,9 @@ static constexpr std::array<const char*, 75> locations_array__ =
  " (in 'cpp-reserved-words.stan', line 14, column 17 to column 19)"};
 
 
-void
+inline void
 _stan_alignas(const int& _stan_asm, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -4028,16 +4024,16 @@ _stan_alignas(const int& _stan_asm, std::ostream* pstream__) {
 }
 
 struct _stan_alignas_functor__ {
-void
+inline void
 operator()(const int& _stan_asm, std::ostream* pstream__)  const 
 {
 return _stan_alignas(_stan_asm, pstream__);
 }
 };
 
-void
+inline void
 _stan_alignof(const int& _stan_char, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -4052,16 +4048,16 @@ _stan_alignof(const int& _stan_char, std::ostream* pstream__) {
 }
 
 struct _stan_alignof_functor__ {
-void
+inline void
 operator()(const int& _stan_char, std::ostream* pstream__)  const 
 {
 return _stan_alignof(_stan_char, pstream__);
 }
 };
 
-void
+inline void
 _stan_and(const int& _stan_STAN_MAJOR, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -4076,7 +4072,7 @@ _stan_and(const int& _stan_STAN_MAJOR, std::ostream* pstream__) {
 }
 
 struct _stan_and_functor__ {
-void
+inline void
 operator()(const int& _stan_STAN_MAJOR, std::ostream* pstream__)  const 
 {
 return _stan_and(_stan_STAN_MAJOR, pstream__);
@@ -4084,9 +4080,9 @@ return _stan_and(_stan_STAN_MAJOR, pstream__);
 };
 
 template <typename T0__>
-void
+inline void
 _stan_and_eq(const T0__& _stan_STAN_MINOR, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -4102,7 +4098,7 @@ _stan_and_eq(const T0__& _stan_STAN_MINOR, std::ostream* pstream__) {
 
 struct _stan_and_eq_functor__ {
 template <typename T0__>
-void
+inline void
 operator()(const T0__& _stan_STAN_MINOR, std::ostream* pstream__)  const 
 {
 return _stan_and_eq(_stan_STAN_MINOR, pstream__);
@@ -4110,9 +4106,9 @@ return _stan_and_eq(_stan_STAN_MINOR, pstream__);
 };
 
 template <typename T0__>
-void
+inline void
 _stan_asm(const T0__& _stan_class_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   const auto& _stan_class = to_ref(_stan_class_arg__);
   static constexpr bool propto__ = true;
@@ -4129,16 +4125,16 @@ _stan_asm(const T0__& _stan_class_arg__, std::ostream* pstream__) {
 
 struct _stan_asm_functor__ {
 template <typename T0__>
-void
+inline void
 operator()(const T0__& _stan_class, std::ostream* pstream__)  const 
 {
 return _stan_asm(_stan_class, pstream__);
 }
 };
 
-void
+inline void
 _stan_bitand(const int& _stan_constexpr, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -4153,14 +4149,14 @@ _stan_bitand(const int& _stan_constexpr, std::ostream* pstream__) {
 }
 
 struct _stan_bitand_functor__ {
-void
+inline void
 operator()(const int& _stan_constexpr, std::ostream* pstream__)  const 
 {
 return _stan_bitand(_stan_constexpr, pstream__);
 }
 };
 
-void
+inline void
 _stan_bitor(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -4177,14 +4173,14 @@ _stan_bitor(std::ostream* pstream__) {
 }
 
 struct _stan_bitor_functor__ {
-void
+inline void
 operator()(std::ostream* pstream__)  const 
 {
 return _stan_bitor(pstream__);
 }
 };
 
-void
+inline void
 _stan_bool(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -4201,14 +4197,14 @@ _stan_bool(std::ostream* pstream__) {
 }
 
 struct _stan_bool_functor__ {
-void
+inline void
 operator()(std::ostream* pstream__)  const 
 {
 return _stan_bool(pstream__);
 }
 };
 
-void
+inline void
 _stan_case(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -4225,14 +4221,14 @@ _stan_case(std::ostream* pstream__) {
 }
 
 struct _stan_case_functor__ {
-void
+inline void
 operator()(std::ostream* pstream__)  const 
 {
 return _stan_case(pstream__);
 }
 };
 
-void
+inline void
 _stan_catch(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -4249,14 +4245,14 @@ _stan_catch(std::ostream* pstream__) {
 }
 
 struct _stan_catch_functor__ {
-void
+inline void
 operator()(std::ostream* pstream__)  const 
 {
 return _stan_catch(pstream__);
 }
 };
 
-void
+inline void
 _stan_char(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -4273,14 +4269,14 @@ _stan_char(std::ostream* pstream__) {
 }
 
 struct _stan_char_functor__ {
-void
+inline void
 operator()(std::ostream* pstream__)  const 
 {
 return _stan_char(pstream__);
 }
 };
 
-void
+inline void
 _stan_char16_t(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -4297,14 +4293,14 @@ _stan_char16_t(std::ostream* pstream__) {
 }
 
 struct _stan_char16_t_functor__ {
-void
+inline void
 operator()(std::ostream* pstream__)  const 
 {
 return _stan_char16_t(pstream__);
 }
 };
 
-void
+inline void
 _stan_char32_t(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -4321,7 +4317,7 @@ _stan_char32_t(std::ostream* pstream__) {
 }
 
 struct _stan_char32_t_functor__ {
-void
+inline void
 operator()(std::ostream* pstream__)  const 
 {
 return _stan_char32_t(pstream__);
@@ -6957,12 +6953,12 @@ static constexpr std::array<const char*, 787> locations_array__ =
  " (in 'mother.stan', line 345, column 41 to line 349, column 3)"};
 
 
-int
+inline int
 foo(const int& n, std::ostream* pstream__) ;
 
-int
+inline int
 foo(const int& n, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -6983,27 +6979,31 @@ foo(const int& n, std::ostream* pstream__) {
 }
 
 struct foo_functor__ {
-int
+inline int
 operator()(const int& n, std::ostream* pstream__)  const 
 {
 return foo(n, pstream__);
 }
 };
 
-template <typename T0__, typename T1__, typename T2__>
-std::vector<stan::promote_args_t<T0__, T1__,
-T2__>>
-sho(const T0__& t, const std::vector<T1__>& y,
-    const std::vector<T2__>& theta, const std::vector<double>& x,
-    const std::vector<int>& x_int, std::ostream* pstream__) ;
-
-template <typename T0__, typename T1__, typename T2__>
-std::vector<stan::promote_args_t<T0__, T1__,
-T2__>>
-sho(const T0__& t, const std::vector<T1__>& y,
-    const std::vector<T2__>& theta, const std::vector<double>& x,
-    const std::vector<int>& x_int, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T1__, T2__>;
+template <typename T0__, typename T1__, typename Alloc1__, typename T2__,
+typename Alloc2__, typename T3__, typename Alloc3__, typename T4__,
+typename Alloc4__>
+inline std::vector<stan::return_type_t<T0__, T1__, T2__, T3__, T4__>>
+sho(const T0__& t, const std::vector<T1__, Alloc1__>& y,
+    const std::vector<T2__, Alloc2__>& theta,
+    const std::vector<T3__, Alloc3__>& x,
+    const std::vector<T4__, Alloc4__>& x_int, std::ostream* pstream__) ;
+
+template <typename T0__, typename T1__, typename Alloc1__, typename T2__,
+typename Alloc2__, typename T3__, typename Alloc3__, typename T4__,
+typename Alloc4__>
+inline std::vector<stan::return_type_t<T0__, T1__, T2__, T3__, T4__>>
+sho(const T0__& t, const std::vector<T1__, Alloc1__>& y,
+    const std::vector<T2__, Alloc2__>& theta,
+    const std::vector<T3__, Alloc3__>& x,
+    const std::vector<T4__, Alloc4__>& x_int, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__, T4__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -7030,18 +7030,20 @@ sho(const T0__& t, const std::vector<T1__>& y,
 }
 
 struct sho_functor__ {
-template <typename T0__, typename T1__, typename T2__>
-std::vector<stan::promote_args_t<T0__, T1__,
-T2__>>
-operator()(const T0__& t, const std::vector<T1__>& y,
-           const std::vector<T2__>& theta, const std::vector<double>& x,
-           const std::vector<int>& x_int, std::ostream* pstream__)  const 
+template <typename T0__, typename T1__, typename Alloc1__, typename T2__,
+typename Alloc2__, typename T3__, typename Alloc3__, typename T4__,
+typename Alloc4__>
+inline std::vector<stan::return_type_t<T0__, T1__, T2__, T3__, T4__>>
+operator()(const T0__& t, const std::vector<T1__, Alloc1__>& y,
+           const std::vector<T2__, Alloc2__>& theta,
+           const std::vector<T3__, Alloc3__>& x,
+           const std::vector<T4__, Alloc4__>& x_int, std::ostream* pstream__)  const 
 {
 return sho(t, y, theta, x, x_int, pstream__);
 }
 };
 
-double
+inline auto
 foo_bar0(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -7059,7 +7061,7 @@ foo_bar0(std::ostream* pstream__) {
 }
 
 struct foo_bar0_functor__ {
-double
+inline auto
 operator()(std::ostream* pstream__)  const 
 {
 return foo_bar0(pstream__);
@@ -7067,9 +7069,9 @@ return foo_bar0(pstream__);
 };
 
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 foo_bar1(const T0__& x, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -7086,7 +7088,7 @@ foo_bar1(const T0__& x, std::ostream* pstream__) {
 
 struct foo_bar1_functor__ {
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& x, std::ostream* pstream__)  const 
 {
 return foo_bar1(x, pstream__);
@@ -7094,10 +7096,9 @@ return foo_bar1(x, pstream__);
 };
 
 template <typename T0__, typename T1__>
-stan::promote_args_t<T0__,
-T1__>
+inline auto
 foo_bar2(const T0__& x, const T1__& y, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T1__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -7114,8 +7115,7 @@ foo_bar2(const T0__& x, const T1__& y, std::ostream* pstream__) {
 
 struct foo_bar2_functor__ {
 template <typename T0__, typename T1__>
-stan::promote_args_t<T0__,
-T1__>
+inline auto
 operator()(const T0__& x, const T1__& y, std::ostream* pstream__)  const 
 {
 return foo_bar2(x, y, pstream__);
@@ -7123,9 +7123,9 @@ return foo_bar2(x, y, pstream__);
 };
 
 template <bool propto__, typename T1__>
-stan::promote_args_t<T1__>
+inline auto
 foo_lpmf(const int& y, const T1__& lambda, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T1__>;
+  using local_scalar_t__ = stan::return_type_t<T1__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -7140,7 +7140,7 @@ foo_lpmf(const int& y, const T1__& lambda, std::ostream* pstream__) {
 
 struct foo_lpmf_functor__ {
 template <bool propto__, typename T1__>
-stan::promote_args_t<T1__>
+inline auto
 operator()(const int& y, const T1__& lambda, std::ostream* pstream__)  const 
 {
 return foo_lpmf<propto__>(y, lambda, pstream__);
@@ -7148,9 +7148,9 @@ return foo_lpmf<propto__>(y, lambda, pstream__);
 };
 
 template <typename T1__>
-stan::promote_args_t<T1__>
+inline auto
 foo_lcdf(const int& y, const T1__& lambda, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T1__>;
+  using local_scalar_t__ = stan::return_type_t<T1__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -7167,7 +7167,7 @@ foo_lcdf(const int& y, const T1__& lambda, std::ostream* pstream__) {
 
 struct foo_lcdf_functor__ {
 template <typename T1__>
-stan::promote_args_t<T1__>
+inline auto
 operator()(const int& y, const T1__& lambda, std::ostream* pstream__)  const 
 {
 return foo_lcdf(y, lambda, pstream__);
@@ -7175,9 +7175,9 @@ return foo_lcdf(y, lambda, pstream__);
 };
 
 template <typename T1__>
-stan::promote_args_t<T1__>
+inline auto
 foo_lccdf(const int& y, const T1__& lambda, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T1__>;
+  using local_scalar_t__ = stan::return_type_t<T1__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -7194,7 +7194,7 @@ foo_lccdf(const int& y, const T1__& lambda, std::ostream* pstream__) {
 
 struct foo_lccdf_functor__ {
 template <typename T1__>
-stan::promote_args_t<T1__>
+inline auto
 operator()(const int& y, const T1__& lambda, std::ostream* pstream__)  const 
 {
 return foo_lccdf(y, lambda, pstream__);
@@ -7202,11 +7202,10 @@ return foo_lccdf(y, lambda, pstream__);
 };
 
 template <typename T0__, typename T1__, typename RNG>
-stan::promote_args_t<T0__,
-T1__>
+inline auto
 foo_rng(const T0__& mu, const T1__& sigma, RNG& base_rng__,
         std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T1__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -7223,8 +7222,7 @@ foo_rng(const T0__& mu, const T1__& sigma, RNG& base_rng__,
 
 struct foo_rng_functor__ {
 template <typename T0__, typename T1__, typename RNG>
-stan::promote_args_t<T0__,
-T1__>
+inline auto
 operator()(const T0__& mu, const T1__& sigma, RNG& base_rng__,
            std::ostream* pstream__)  const 
 {
@@ -7234,10 +7232,10 @@ return foo_rng(mu, sigma, base_rng__, pstream__);
 
 template <bool propto__, typename T0__, typename T_lp__,
 typename T_lp_accum__>
-void
+inline void
 unit_normal_lp(const T0__& u, T_lp__& lp__, T_lp_accum__& lp_accum__,
                std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -7255,7 +7253,7 @@ unit_normal_lp(const T0__& u, T_lp__& lp__, T_lp_accum__& lp_accum__,
 struct unit_normal_lp_functor__ {
 template <bool propto__, typename T0__, typename T_lp__,
 typename T_lp_accum__>
-void
+inline void
 operator()(const T0__& u, T_lp__& lp__, T_lp_accum__& lp_accum__,
            std::ostream* pstream__)  const 
 {
@@ -7263,9 +7261,9 @@ return unit_normal_lp<propto__>(u, lp__, lp_accum__, pstream__);
 }
 };
 
-int
+inline int
 foo_1(const int& a, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -7503,16 +7501,16 @@ foo_1(const int& a, std::ostream* pstream__) {
 }
 
 struct foo_1_functor__ {
-int
+inline int
 operator()(const int& a, std::ostream* pstream__)  const 
 {
 return foo_1(a, pstream__);
 }
 };
 
-int
+inline int
 foo_2(const int& a, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -7544,7 +7542,7 @@ foo_2(const int& a, std::ostream* pstream__) {
 }
 
 struct foo_2_functor__ {
-int
+inline int
 operator()(const int& a, std::ostream* pstream__)  const 
 {
 return foo_2(a, pstream__);
@@ -7552,9 +7550,9 @@ return foo_2(a, pstream__);
 };
 
 template <typename T0__>
-std::vector<stan::promote_args_t<T0__>>
+inline std::vector<stan::return_type_t<T0__>>
 foo_3(const T0__& t, const int& n, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -7571,7 +7569,7 @@ foo_3(const T0__& t, const int& n, std::ostream* pstream__) {
 
 struct foo_3_functor__ {
 template <typename T0__>
-std::vector<stan::promote_args_t<T0__>>
+inline std::vector<stan::return_type_t<T0__>>
 operator()(const T0__& t, const int& n, std::ostream* pstream__)  const 
 {
 return foo_3(t, n, pstream__);
@@ -7580,10 +7578,10 @@ return foo_3(t, n, pstream__);
 
 template <bool propto__, typename T0__, typename T_lp__,
 typename T_lp_accum__>
-stan::promote_args_t<T0__>
+inline auto
 foo_lp(const T0__& x, T_lp__& lp__, T_lp_accum__& lp_accum__,
        std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -7599,7 +7597,7 @@ foo_lp(const T0__& x, T_lp__& lp__, T_lp_accum__& lp_accum__,
 struct foo_lp_functor__ {
 template <bool propto__, typename T0__, typename T_lp__,
 typename T_lp_accum__>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& x, T_lp__& lp__, T_lp_accum__& lp_accum__,
            std::ostream* pstream__)  const 
 {
@@ -7608,9 +7606,9 @@ return foo_lp<propto__>(x, lp__, lp_accum__, pstream__);
 };
 
 template <typename T0__>
-void
+inline void
 foo_4(const T0__& x, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -7630,7 +7628,7 @@ foo_4(const T0__& x, std::ostream* pstream__) {
 
 struct foo_4_functor__ {
 template <typename T0__>
-void
+inline void
 operator()(const T0__& x, std::ostream* pstream__)  const 
 {
 return foo_4(x, pstream__);
@@ -7638,11 +7636,10 @@ return foo_4(x, pstream__);
 };
 
 template <typename T0__, typename T1__, typename T2__, typename T3__>
-stan::promote_args_t<T0__, T1__, T2__,
-T3__>
+inline auto
 relative_diff(const T0__& x, const T1__& y, const T2__& max_,
               const T3__& min_, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T1__, T2__, T3__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -7693,8 +7690,7 @@ relative_diff(const T0__& x, const T1__& y, const T2__& max_,
 
 struct relative_diff_functor__ {
 template <typename T0__, typename T1__, typename T2__, typename T3__>
-stan::promote_args_t<T0__, T1__, T2__,
-T3__>
+inline auto
 operator()(const T0__& x, const T1__& y, const T2__& max_, const T3__& min_,
            std::ostream* pstream__)  const 
 {
@@ -7702,14 +7698,13 @@ return relative_diff(x, y, max_, min_, pstream__);
 }
 };
 
-template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>,
-stan::value_type_t<T1__>>, -1, 1>
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
 foo_5(const T0__& shared_params_arg__, const T1__& job_params_arg__,
-      const std::vector<double>& data_r, const std::vector<int>& data_i,
-      std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>,
-          stan::value_type_t<T1__>>;
+      const std::vector<T2__, Alloc2__>& data_r,
+      const std::vector<T3__, Alloc3__>& data_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__>;
   int current_statement__ = 0; 
   const auto& shared_params = to_ref(shared_params_arg__);
   const auto& job_params = to_ref(job_params_arg__);
@@ -7727,12 +7722,12 @@ foo_5(const T0__& shared_params_arg__, const T1__& job_params_arg__,
 }
 
 struct foo_5_functor__ {
-template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>,
-stan::value_type_t<T1__>>, -1, 1>
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
 operator()(const T0__& shared_params, const T1__& job_params,
-           const std::vector<double>& data_r, const std::vector<int>& data_i,
-           std::ostream* pstream__)  const 
+           const std::vector<T2__, Alloc2__>& data_r,
+           const std::vector<T3__, Alloc3__>& data_i, std::ostream* pstream__)  const 
 {
 return foo_5(shared_params, job_params, data_r, data_i, pstream__);
 }
@@ -7740,15 +7735,10 @@ return foo_5(shared_params, job_params, data_r, data_i, pstream__);
 
 template <typename T0__, typename T1__, typename T2__, typename T3__,
 typename T4__>
-stan::promote_args_t<T0__, T1__, T2__, T3__,
-T4__>
+inline auto
 foo_five_args(const T0__& x1, const T1__& x2, const T2__& x3, const T3__& x4,
               const T4__& x5, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__,
-          T1__,
-          T2__,
-          T3__,
-          T4__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__, T4__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -7766,8 +7756,7 @@ foo_five_args(const T0__& x1, const T1__& x2, const T2__& x3, const T3__& x4,
 struct foo_five_args_functor__ {
 template <typename T0__, typename T1__, typename T2__, typename T3__,
 typename T4__>
-stan::promote_args_t<T0__, T1__, T2__, T3__,
-T4__>
+inline auto
 operator()(const T0__& x1, const T1__& x2, const T2__& x3, const T3__& x4,
            const T4__& x5, std::ostream* pstream__)  const 
 {
@@ -7778,17 +7767,12 @@ return foo_five_args(x1, x2, x3, x4, x5, pstream__);
 template <bool propto__, typename T0__, typename T1__, typename T2__,
 typename T3__, typename T4__, typename T5__, typename T_lp__,
 typename T_lp_accum__>
-stan::promote_args_t<T0__, T1__, T2__, T3__,
-T4__, stan::promote_args_t<T5__>>
+inline auto
 foo_five_args_lp(const T0__& x1, const T1__& x2, const T2__& x3,
                  const T3__& x4, const T4__& x5, const T5__& x6,
                  T_lp__& lp__, T_lp_accum__& lp_accum__,
                  std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__,
-          T1__,
-          T2__,
-          T3__,
-          T4__, stan::promote_args_t<T5__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__, T4__, T5__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -7805,8 +7789,7 @@ struct foo_five_args_lp_functor__ {
 template <bool propto__, typename T0__, typename T1__, typename T2__,
 typename T3__, typename T4__, typename T5__, typename T_lp__,
 typename T_lp_accum__>
-stan::promote_args_t<T0__, T1__, T2__, T3__,
-T4__, stan::promote_args_t<T5__>>
+inline auto
 operator()(const T0__& x1, const T1__& x2, const T2__& x3, const T3__& x4,
            const T4__& x5, const T5__& x6, T_lp__& lp__,
            T_lp_accum__& lp_accum__, std::ostream* pstream__)  const 
@@ -7817,10 +7800,10 @@ return foo_five_args_lp<propto__>(x1, x2, x3, x4, x5, x6, lp__, lp_accum__,
 };
 
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, -1>
 covsqrt2corsqrt(const T0__& mat_arg__, const int& invert,
                 std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   const auto& mat = to_ref(mat_arg__);
   static constexpr bool propto__ = true;
@@ -7854,33 +7837,28 @@ covsqrt2corsqrt(const T0__& mat_arg__, const int& invert,
 
 struct covsqrt2corsqrt_functor__ {
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, -1>
 operator()(const T0__& mat, const int& invert, std::ostream* pstream__)  const 
 {
 return covsqrt2corsqrt(mat, invert, pstream__);
 }
 };
 
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-void
-f0(const int& a1, const std::vector<int>& a2,
-   const std::vector<std::vector<int>>& a3, const T3__& a4,
-   const std::vector<T4__>& a5, const std::vector<std::vector<T5__>>& a6,
-   const T6__& a7_arg__, const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-   const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-   const T9__& a10_arg__,
-   const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-   const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T3__,
-          T4__,
-          T5__,
-          stan::value_type_t<T6__>,
-          T7__, stan::promote_args_t<T8__,
-          stan::value_type_t<T9__>,
-          T10__,
-          T11__>>;
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline void
+f0(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+   const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+   const std::vector<T4__, Alloc4__>& a5,
+   const std::vector<T5__, Alloc5__>& a6, const T6__& a7_arg__,
+   const std::vector<T7__, Alloc7__>& a8,
+   const std::vector<T8__, Alloc8__>& a9, const T9__& a10_arg__,
+   const std::vector<T10__, Alloc10__>& a11,
+   const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>;
   int current_statement__ = 0; 
   const auto& a7 = to_ref(a7_arg__);
   const auto& a10 = to_ref(a10_arg__);
@@ -7901,44 +7879,40 @@ f0(const int& a1, const std::vector<int>& a2,
 }
 
 struct f0_functor__ {
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-void
-operator()(const int& a1, const std::vector<int>& a2,
-           const std::vector<std::vector<int>>& a3, const T3__& a4,
-           const std::vector<T4__>& a5,
-           const std::vector<std::vector<T5__>>& a6, const T6__& a7,
-           const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-           const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-           const T9__& a10,
-           const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-           const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-           std::ostream* pstream__)  const 
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline void
+operator()(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+           const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+           const std::vector<T4__, Alloc4__>& a5,
+           const std::vector<T5__, Alloc5__>& a6, const T6__& a7,
+           const std::vector<T7__, Alloc7__>& a8,
+           const std::vector<T8__, Alloc8__>& a9, const T9__& a10,
+           const std::vector<T10__, Alloc10__>& a11,
+           const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__)  const 
 {
 return f0(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, pstream__);
 }
 };
 
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-int
-f1(const int& a1, const std::vector<int>& a2,
-   const std::vector<std::vector<int>>& a3, const T3__& a4,
-   const std::vector<T4__>& a5, const std::vector<std::vector<T5__>>& a6,
-   const T6__& a7_arg__, const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-   const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-   const T9__& a10_arg__,
-   const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-   const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T3__,
-          T4__,
-          T5__,
-          stan::value_type_t<T6__>,
-          T7__, stan::promote_args_t<T8__,
-          stan::value_type_t<T9__>,
-          T10__,
-          T11__>>;
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline int
+f1(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+   const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+   const std::vector<T4__, Alloc4__>& a5,
+   const std::vector<T5__, Alloc5__>& a6, const T6__& a7_arg__,
+   const std::vector<T7__, Alloc7__>& a8,
+   const std::vector<T8__, Alloc8__>& a9, const T9__& a10_arg__,
+   const std::vector<T10__, Alloc10__>& a11,
+   const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>;
   int current_statement__ = 0; 
   const auto& a7 = to_ref(a7_arg__);
   const auto& a10 = to_ref(a10_arg__);
@@ -7956,44 +7930,40 @@ f1(const int& a1, const std::vector<int>& a2,
 }
 
 struct f1_functor__ {
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-int
-operator()(const int& a1, const std::vector<int>& a2,
-           const std::vector<std::vector<int>>& a3, const T3__& a4,
-           const std::vector<T4__>& a5,
-           const std::vector<std::vector<T5__>>& a6, const T6__& a7,
-           const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-           const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-           const T9__& a10,
-           const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-           const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-           std::ostream* pstream__)  const 
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline int
+operator()(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+           const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+           const std::vector<T4__, Alloc4__>& a5,
+           const std::vector<T5__, Alloc5__>& a6, const T6__& a7,
+           const std::vector<T7__, Alloc7__>& a8,
+           const std::vector<T8__, Alloc8__>& a9, const T9__& a10,
+           const std::vector<T10__, Alloc10__>& a11,
+           const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__)  const 
 {
 return f1(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, pstream__);
 }
 };
 
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<int>
-f2(const int& a1, const std::vector<int>& a2,
-   const std::vector<std::vector<int>>& a3, const T3__& a4,
-   const std::vector<T4__>& a5, const std::vector<std::vector<T5__>>& a6,
-   const T6__& a7_arg__, const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-   const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-   const T9__& a10_arg__,
-   const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-   const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T3__,
-          T4__,
-          T5__,
-          stan::value_type_t<T6__>,
-          T7__, stan::promote_args_t<T8__,
-          stan::value_type_t<T9__>,
-          T10__,
-          T11__>>;
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<int>
+f2(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+   const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+   const std::vector<T4__, Alloc4__>& a5,
+   const std::vector<T5__, Alloc5__>& a6, const T6__& a7_arg__,
+   const std::vector<T7__, Alloc7__>& a8,
+   const std::vector<T8__, Alloc8__>& a9, const T9__& a10_arg__,
+   const std::vector<T10__, Alloc10__>& a11,
+   const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>;
   int current_statement__ = 0; 
   const auto& a7 = to_ref(a7_arg__);
   const auto& a10 = to_ref(a10_arg__);
@@ -8011,44 +7981,40 @@ f2(const int& a1, const std::vector<int>& a2,
 }
 
 struct f2_functor__ {
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<int>
-operator()(const int& a1, const std::vector<int>& a2,
-           const std::vector<std::vector<int>>& a3, const T3__& a4,
-           const std::vector<T4__>& a5,
-           const std::vector<std::vector<T5__>>& a6, const T6__& a7,
-           const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-           const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-           const T9__& a10,
-           const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-           const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-           std::ostream* pstream__)  const 
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<int>
+operator()(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+           const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+           const std::vector<T4__, Alloc4__>& a5,
+           const std::vector<T5__, Alloc5__>& a6, const T6__& a7,
+           const std::vector<T7__, Alloc7__>& a8,
+           const std::vector<T8__, Alloc8__>& a9, const T9__& a10,
+           const std::vector<T10__, Alloc10__>& a11,
+           const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__)  const 
 {
 return f2(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, pstream__);
 }
 };
 
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<std::vector<int>>
-f3(const int& a1, const std::vector<int>& a2,
-   const std::vector<std::vector<int>>& a3, const T3__& a4,
-   const std::vector<T4__>& a5, const std::vector<std::vector<T5__>>& a6,
-   const T6__& a7_arg__, const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-   const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-   const T9__& a10_arg__,
-   const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-   const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T3__,
-          T4__,
-          T5__,
-          stan::value_type_t<T6__>,
-          T7__, stan::promote_args_t<T8__,
-          stan::value_type_t<T9__>,
-          T10__,
-          T11__>>;
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<std::vector<int>>
+f3(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+   const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+   const std::vector<T4__, Alloc4__>& a5,
+   const std::vector<T5__, Alloc5__>& a6, const T6__& a7_arg__,
+   const std::vector<T7__, Alloc7__>& a8,
+   const std::vector<T8__, Alloc8__>& a9, const T9__& a10_arg__,
+   const std::vector<T10__, Alloc10__>& a11,
+   const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>;
   int current_statement__ = 0; 
   const auto& a7 = to_ref(a7_arg__);
   const auto& a10 = to_ref(a10_arg__);
@@ -8066,46 +8032,40 @@ f3(const int& a1, const std::vector<int>& a2,
 }
 
 struct f3_functor__ {
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<std::vector<int>>
-operator()(const int& a1, const std::vector<int>& a2,
-           const std::vector<std::vector<int>>& a3, const T3__& a4,
-           const std::vector<T4__>& a5,
-           const std::vector<std::vector<T5__>>& a6, const T6__& a7,
-           const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-           const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-           const T9__& a10,
-           const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-           const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-           std::ostream* pstream__)  const 
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<std::vector<int>>
+operator()(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+           const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+           const std::vector<T4__, Alloc4__>& a5,
+           const std::vector<T5__, Alloc5__>& a6, const T6__& a7,
+           const std::vector<T7__, Alloc7__>& a8,
+           const std::vector<T8__, Alloc8__>& a9, const T9__& a10,
+           const std::vector<T10__, Alloc10__>& a11,
+           const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__)  const 
 {
 return f3(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, pstream__);
 }
 };
 
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>
-f4(const int& a1, const std::vector<int>& a2,
-   const std::vector<std::vector<int>>& a3, const T3__& a4,
-   const std::vector<T4__>& a5, const std::vector<std::vector<T5__>>& a6,
-   const T6__& a7_arg__, const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-   const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-   const T9__& a10_arg__,
-   const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-   const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T3__,
-          T4__,
-          T5__,
-          stan::value_type_t<T6__>,
-          T7__, stan::promote_args_t<T8__,
-          stan::value_type_t<T9__>,
-          T10__,
-          T11__>>;
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline auto
+f4(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+   const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+   const std::vector<T4__, Alloc4__>& a5,
+   const std::vector<T5__, Alloc5__>& a6, const T6__& a7_arg__,
+   const std::vector<T7__, Alloc7__>& a8,
+   const std::vector<T8__, Alloc8__>& a9, const T9__& a10_arg__,
+   const std::vector<T10__, Alloc10__>& a11,
+   const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>;
   int current_statement__ = 0; 
   const auto& a7 = to_ref(a7_arg__);
   const auto& a10 = to_ref(a10_arg__);
@@ -8123,48 +8083,40 @@ f4(const int& a1, const std::vector<int>& a2,
 }
 
 struct f4_functor__ {
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>
-operator()(const int& a1, const std::vector<int>& a2,
-           const std::vector<std::vector<int>>& a3, const T3__& a4,
-           const std::vector<T4__>& a5,
-           const std::vector<std::vector<T5__>>& a6, const T6__& a7,
-           const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-           const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-           const T9__& a10,
-           const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-           const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-           std::ostream* pstream__)  const 
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline auto
+operator()(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+           const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+           const std::vector<T4__, Alloc4__>& a5,
+           const std::vector<T5__, Alloc5__>& a6, const T6__& a7,
+           const std::vector<T7__, Alloc7__>& a8,
+           const std::vector<T8__, Alloc8__>& a9, const T9__& a10,
+           const std::vector<T10__, Alloc10__>& a11,
+           const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__)  const 
 {
 return f4(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, pstream__);
 }
 };
 
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>>
-f5(const int& a1, const std::vector<int>& a2,
-   const std::vector<std::vector<int>>& a3, const T3__& a4,
-   const std::vector<T4__>& a5, const std::vector<std::vector<T5__>>& a6,
-   const T6__& a7_arg__, const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-   const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-   const T9__& a10_arg__,
-   const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-   const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T3__,
-          T4__,
-          T5__,
-          stan::value_type_t<T6__>,
-          T7__, stan::promote_args_t<T8__,
-          stan::value_type_t<T9__>,
-          T10__,
-          T11__>>;
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>>
+f5(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+   const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+   const std::vector<T4__, Alloc4__>& a5,
+   const std::vector<T5__, Alloc5__>& a6, const T6__& a7_arg__,
+   const std::vector<T7__, Alloc7__>& a8,
+   const std::vector<T8__, Alloc8__>& a9, const T9__& a10_arg__,
+   const std::vector<T10__, Alloc10__>& a11,
+   const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>;
   int current_statement__ = 0; 
   const auto& a7 = to_ref(a7_arg__);
   const auto& a10 = to_ref(a10_arg__);
@@ -8182,48 +8134,40 @@ f5(const int& a1, const std::vector<int>& a2,
 }
 
 struct f5_functor__ {
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>>
-operator()(const int& a1, const std::vector<int>& a2,
-           const std::vector<std::vector<int>>& a3, const T3__& a4,
-           const std::vector<T4__>& a5,
-           const std::vector<std::vector<T5__>>& a6, const T6__& a7,
-           const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-           const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-           const T9__& a10,
-           const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-           const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-           std::ostream* pstream__)  const 
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>>
+operator()(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+           const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+           const std::vector<T4__, Alloc4__>& a5,
+           const std::vector<T5__, Alloc5__>& a6, const T6__& a7,
+           const std::vector<T7__, Alloc7__>& a8,
+           const std::vector<T8__, Alloc8__>& a9, const T9__& a10,
+           const std::vector<T10__, Alloc10__>& a11,
+           const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__)  const 
 {
 return f5(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, pstream__);
 }
 };
 
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<std::vector<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>>>
-f6(const int& a1, const std::vector<int>& a2,
-   const std::vector<std::vector<int>>& a3, const T3__& a4,
-   const std::vector<T4__>& a5, const std::vector<std::vector<T5__>>& a6,
-   const T6__& a7_arg__, const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-   const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-   const T9__& a10_arg__,
-   const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-   const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T3__,
-          T4__,
-          T5__,
-          stan::value_type_t<T6__>,
-          T7__, stan::promote_args_t<T8__,
-          stan::value_type_t<T9__>,
-          T10__,
-          T11__>>;
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<std::vector<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>>>
+f6(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+   const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+   const std::vector<T4__, Alloc4__>& a5,
+   const std::vector<T5__, Alloc5__>& a6, const T6__& a7_arg__,
+   const std::vector<T7__, Alloc7__>& a8,
+   const std::vector<T8__, Alloc8__>& a9, const T9__& a10_arg__,
+   const std::vector<T10__, Alloc10__>& a11,
+   const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>;
   int current_statement__ = 0; 
   const auto& a7 = to_ref(a7_arg__);
   const auto& a10 = to_ref(a10_arg__);
@@ -8241,48 +8185,40 @@ f6(const int& a1, const std::vector<int>& a2,
 }
 
 struct f6_functor__ {
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<std::vector<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>>>
-operator()(const int& a1, const std::vector<int>& a2,
-           const std::vector<std::vector<int>>& a3, const T3__& a4,
-           const std::vector<T4__>& a5,
-           const std::vector<std::vector<T5__>>& a6, const T6__& a7,
-           const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-           const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-           const T9__& a10,
-           const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-           const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-           std::ostream* pstream__)  const 
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<std::vector<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>>>
+operator()(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+           const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+           const std::vector<T4__, Alloc4__>& a5,
+           const std::vector<T5__, Alloc5__>& a6, const T6__& a7,
+           const std::vector<T7__, Alloc7__>& a8,
+           const std::vector<T8__, Alloc8__>& a9, const T9__& a10,
+           const std::vector<T10__, Alloc10__>& a11,
+           const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__)  const 
 {
 return f6(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, pstream__);
 }
 };
 
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-Eigen::Matrix<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>, -1, 1>
-f7(const int& a1, const std::vector<int>& a2,
-   const std::vector<std::vector<int>>& a3, const T3__& a4,
-   const std::vector<T4__>& a5, const std::vector<std::vector<T5__>>& a6,
-   const T6__& a7_arg__, const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-   const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-   const T9__& a10_arg__,
-   const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-   const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T3__,
-          T4__,
-          T5__,
-          stan::value_type_t<T6__>,
-          T7__, stan::promote_args_t<T8__,
-          stan::value_type_t<T9__>,
-          T10__,
-          T11__>>;
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline Eigen::Matrix<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>, -1, 1>
+f7(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+   const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+   const std::vector<T4__, Alloc4__>& a5,
+   const std::vector<T5__, Alloc5__>& a6, const T6__& a7_arg__,
+   const std::vector<T7__, Alloc7__>& a8,
+   const std::vector<T8__, Alloc8__>& a9, const T9__& a10_arg__,
+   const std::vector<T10__, Alloc10__>& a11,
+   const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>;
   int current_statement__ = 0; 
   const auto& a7 = to_ref(a7_arg__);
   const auto& a10 = to_ref(a10_arg__);
@@ -8300,48 +8236,40 @@ f7(const int& a1, const std::vector<int>& a2,
 }
 
 struct f7_functor__ {
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-Eigen::Matrix<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>, -1, 1>
-operator()(const int& a1, const std::vector<int>& a2,
-           const std::vector<std::vector<int>>& a3, const T3__& a4,
-           const std::vector<T4__>& a5,
-           const std::vector<std::vector<T5__>>& a6, const T6__& a7,
-           const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-           const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-           const T9__& a10,
-           const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-           const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-           std::ostream* pstream__)  const 
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline Eigen::Matrix<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>, -1, 1>
+operator()(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+           const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+           const std::vector<T4__, Alloc4__>& a5,
+           const std::vector<T5__, Alloc5__>& a6, const T6__& a7,
+           const std::vector<T7__, Alloc7__>& a8,
+           const std::vector<T8__, Alloc8__>& a9, const T9__& a10,
+           const std::vector<T10__, Alloc10__>& a11,
+           const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__)  const 
 {
 return f7(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, pstream__);
 }
 };
 
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<Eigen::Matrix<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>, -1, 1>>
-f8(const int& a1, const std::vector<int>& a2,
-   const std::vector<std::vector<int>>& a3, const T3__& a4,
-   const std::vector<T4__>& a5, const std::vector<std::vector<T5__>>& a6,
-   const T6__& a7_arg__, const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-   const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-   const T9__& a10_arg__,
-   const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-   const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T3__,
-          T4__,
-          T5__,
-          stan::value_type_t<T6__>,
-          T7__, stan::promote_args_t<T8__,
-          stan::value_type_t<T9__>,
-          T10__,
-          T11__>>;
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<Eigen::Matrix<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>, -1, 1>>
+f8(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+   const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+   const std::vector<T4__, Alloc4__>& a5,
+   const std::vector<T5__, Alloc5__>& a6, const T6__& a7_arg__,
+   const std::vector<T7__, Alloc7__>& a8,
+   const std::vector<T8__, Alloc8__>& a9, const T9__& a10_arg__,
+   const std::vector<T10__, Alloc10__>& a11,
+   const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>;
   int current_statement__ = 0; 
   const auto& a7 = to_ref(a7_arg__);
   const auto& a10 = to_ref(a10_arg__);
@@ -8359,48 +8287,40 @@ f8(const int& a1, const std::vector<int>& a2,
 }
 
 struct f8_functor__ {
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<Eigen::Matrix<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>, -1, 1>>
-operator()(const int& a1, const std::vector<int>& a2,
-           const std::vector<std::vector<int>>& a3, const T3__& a4,
-           const std::vector<T4__>& a5,
-           const std::vector<std::vector<T5__>>& a6, const T6__& a7,
-           const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-           const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-           const T9__& a10,
-           const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-           const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-           std::ostream* pstream__)  const 
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<Eigen::Matrix<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>, -1, 1>>
+operator()(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+           const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+           const std::vector<T4__, Alloc4__>& a5,
+           const std::vector<T5__, Alloc5__>& a6, const T6__& a7,
+           const std::vector<T7__, Alloc7__>& a8,
+           const std::vector<T8__, Alloc8__>& a9, const T9__& a10,
+           const std::vector<T10__, Alloc10__>& a11,
+           const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__)  const 
 {
 return f8(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, pstream__);
 }
 };
 
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<std::vector<Eigen::Matrix<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>, -1, 1>>>
-f9(const int& a1, const std::vector<int>& a2,
-   const std::vector<std::vector<int>>& a3, const T3__& a4,
-   const std::vector<T4__>& a5, const std::vector<std::vector<T5__>>& a6,
-   const T6__& a7_arg__, const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-   const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-   const T9__& a10_arg__,
-   const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-   const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T3__,
-          T4__,
-          T5__,
-          stan::value_type_t<T6__>,
-          T7__, stan::promote_args_t<T8__,
-          stan::value_type_t<T9__>,
-          T10__,
-          T11__>>;
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<std::vector<Eigen::Matrix<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>, -1, 1>>>
+f9(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+   const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+   const std::vector<T4__, Alloc4__>& a5,
+   const std::vector<T5__, Alloc5__>& a6, const T6__& a7_arg__,
+   const std::vector<T7__, Alloc7__>& a8,
+   const std::vector<T8__, Alloc8__>& a9, const T9__& a10_arg__,
+   const std::vector<T10__, Alloc10__>& a11,
+   const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>;
   int current_statement__ = 0; 
   const auto& a7 = to_ref(a7_arg__);
   const auto& a10 = to_ref(a10_arg__);
@@ -8418,48 +8338,40 @@ f9(const int& a1, const std::vector<int>& a2,
 }
 
 struct f9_functor__ {
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<std::vector<Eigen::Matrix<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>, -1, 1>>>
-operator()(const int& a1, const std::vector<int>& a2,
-           const std::vector<std::vector<int>>& a3, const T3__& a4,
-           const std::vector<T4__>& a5,
-           const std::vector<std::vector<T5__>>& a6, const T6__& a7,
-           const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-           const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-           const T9__& a10,
-           const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-           const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-           std::ostream* pstream__)  const 
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<std::vector<Eigen::Matrix<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>, -1, 1>>>
+operator()(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+           const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+           const std::vector<T4__, Alloc4__>& a5,
+           const std::vector<T5__, Alloc5__>& a6, const T6__& a7,
+           const std::vector<T7__, Alloc7__>& a8,
+           const std::vector<T8__, Alloc8__>& a9, const T9__& a10,
+           const std::vector<T10__, Alloc10__>& a11,
+           const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__)  const 
 {
 return f9(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, pstream__);
 }
 };
 
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-Eigen::Matrix<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>, -1, -1>
-f10(const int& a1, const std::vector<int>& a2,
-    const std::vector<std::vector<int>>& a3, const T3__& a4,
-    const std::vector<T4__>& a5, const std::vector<std::vector<T5__>>& a6,
-    const T6__& a7_arg__, const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-    const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-    const T9__& a10_arg__,
-    const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-    const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-    std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T3__,
-          T4__,
-          T5__,
-          stan::value_type_t<T6__>,
-          T7__, stan::promote_args_t<T8__,
-          stan::value_type_t<T9__>,
-          T10__,
-          T11__>>;
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline Eigen::Matrix<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>, -1, -1>
+f10(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+    const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+    const std::vector<T4__, Alloc4__>& a5,
+    const std::vector<T5__, Alloc5__>& a6, const T6__& a7_arg__,
+    const std::vector<T7__, Alloc7__>& a8,
+    const std::vector<T8__, Alloc8__>& a9, const T9__& a10_arg__,
+    const std::vector<T10__, Alloc10__>& a11,
+    const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>;
   int current_statement__ = 0; 
   const auto& a7 = to_ref(a7_arg__);
   const auto& a10 = to_ref(a10_arg__);
@@ -8477,48 +8389,40 @@ f10(const int& a1, const std::vector<int>& a2,
 }
 
 struct f10_functor__ {
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-Eigen::Matrix<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>, -1, -1>
-operator()(const int& a1, const std::vector<int>& a2,
-           const std::vector<std::vector<int>>& a3, const T3__& a4,
-           const std::vector<T4__>& a5,
-           const std::vector<std::vector<T5__>>& a6, const T6__& a7,
-           const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-           const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-           const T9__& a10,
-           const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-           const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-           std::ostream* pstream__)  const 
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline Eigen::Matrix<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>, -1, -1>
+operator()(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+           const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+           const std::vector<T4__, Alloc4__>& a5,
+           const std::vector<T5__, Alloc5__>& a6, const T6__& a7,
+           const std::vector<T7__, Alloc7__>& a8,
+           const std::vector<T8__, Alloc8__>& a9, const T9__& a10,
+           const std::vector<T10__, Alloc10__>& a11,
+           const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__)  const 
 {
 return f10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, pstream__);
 }
 };
 
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<Eigen::Matrix<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>, -1, -1>>
-f11(const int& a1, const std::vector<int>& a2,
-    const std::vector<std::vector<int>>& a3, const T3__& a4,
-    const std::vector<T4__>& a5, const std::vector<std::vector<T5__>>& a6,
-    const T6__& a7_arg__, const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-    const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-    const T9__& a10_arg__,
-    const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-    const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-    std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T3__,
-          T4__,
-          T5__,
-          stan::value_type_t<T6__>,
-          T7__, stan::promote_args_t<T8__,
-          stan::value_type_t<T9__>,
-          T10__,
-          T11__>>;
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<Eigen::Matrix<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>, -1, -1>>
+f11(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+    const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+    const std::vector<T4__, Alloc4__>& a5,
+    const std::vector<T5__, Alloc5__>& a6, const T6__& a7_arg__,
+    const std::vector<T7__, Alloc7__>& a8,
+    const std::vector<T8__, Alloc8__>& a9, const T9__& a10_arg__,
+    const std::vector<T10__, Alloc10__>& a11,
+    const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>;
   int current_statement__ = 0; 
   const auto& a7 = to_ref(a7_arg__);
   const auto& a10 = to_ref(a10_arg__);
@@ -8536,48 +8440,40 @@ f11(const int& a1, const std::vector<int>& a2,
 }
 
 struct f11_functor__ {
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<Eigen::Matrix<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>, -1, -1>>
-operator()(const int& a1, const std::vector<int>& a2,
-           const std::vector<std::vector<int>>& a3, const T3__& a4,
-           const std::vector<T4__>& a5,
-           const std::vector<std::vector<T5__>>& a6, const T6__& a7,
-           const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-           const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-           const T9__& a10,
-           const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-           const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-           std::ostream* pstream__)  const 
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<Eigen::Matrix<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>, -1, -1>>
+operator()(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+           const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+           const std::vector<T4__, Alloc4__>& a5,
+           const std::vector<T5__, Alloc5__>& a6, const T6__& a7,
+           const std::vector<T7__, Alloc7__>& a8,
+           const std::vector<T8__, Alloc8__>& a9, const T9__& a10,
+           const std::vector<T10__, Alloc10__>& a11,
+           const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__)  const 
 {
 return f11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, pstream__);
 }
 };
 
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<std::vector<Eigen::Matrix<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>, -1, -1>>>
-f12(const int& a1, const std::vector<int>& a2,
-    const std::vector<std::vector<int>>& a3, const T3__& a4,
-    const std::vector<T4__>& a5, const std::vector<std::vector<T5__>>& a6,
-    const T6__& a7_arg__, const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-    const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-    const T9__& a10_arg__,
-    const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-    const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-    std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T3__,
-          T4__,
-          T5__,
-          stan::value_type_t<T6__>,
-          T7__, stan::promote_args_t<T8__,
-          stan::value_type_t<T9__>,
-          T10__,
-          T11__>>;
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<std::vector<Eigen::Matrix<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>, -1, -1>>>
+f12(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+    const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+    const std::vector<T4__, Alloc4__>& a5,
+    const std::vector<T5__, Alloc5__>& a6, const T6__& a7_arg__,
+    const std::vector<T7__, Alloc7__>& a8,
+    const std::vector<T8__, Alloc8__>& a9, const T9__& a10_arg__,
+    const std::vector<T10__, Alloc10__>& a11,
+    const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>;
   int current_statement__ = 0; 
   const auto& a7 = to_ref(a7_arg__);
   const auto& a10 = to_ref(a10_arg__);
@@ -8595,27 +8491,26 @@ f12(const int& a1, const std::vector<int>& a2,
 }
 
 struct f12_functor__ {
-template <typename T3__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T8__, typename T9__, typename T10__, typename T11__>
-std::vector<std::vector<Eigen::Matrix<stan::promote_args_t<T3__, T4__, T5__, stan::value_type_t<T6__>,
-T7__, stan::promote_args_t<T8__, stan::value_type_t<T9__>, T10__,
-T11__>>, -1, -1>>>
-operator()(const int& a1, const std::vector<int>& a2,
-           const std::vector<std::vector<int>>& a3, const T3__& a4,
-           const std::vector<T4__>& a5,
-           const std::vector<std::vector<T5__>>& a6, const T6__& a7,
-           const std::vector<Eigen::Matrix<T7__, -1, 1>>& a8,
-           const std::vector<std::vector<Eigen::Matrix<T8__, -1, 1>>>& a9,
-           const T9__& a10,
-           const std::vector<Eigen::Matrix<T10__, -1, -1>>& a11,
-           const std::vector<std::vector<Eigen::Matrix<T11__, -1, -1>>>& a12,
-           std::ostream* pstream__)  const 
+template <typename T1__, typename Alloc1__, typename T2__, typename Alloc2__,
+typename T3__, typename T4__, typename Alloc4__, typename T5__,
+typename Alloc5__, typename T6__, typename T7__, typename Alloc7__,
+typename T8__, typename Alloc8__, typename T9__, typename T10__,
+typename Alloc10__, typename T11__, typename Alloc11__>
+inline std::vector<std::vector<Eigen::Matrix<stan::return_type_t<T1__, T2__, T3__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__>, -1, -1>>>
+operator()(const int& a1, const std::vector<T1__, Alloc1__>& a2,
+           const std::vector<T2__, Alloc2__>& a3, const T3__& a4,
+           const std::vector<T4__, Alloc4__>& a5,
+           const std::vector<T5__, Alloc5__>& a6, const T6__& a7,
+           const std::vector<T7__, Alloc7__>& a8,
+           const std::vector<T8__, Alloc8__>& a9, const T9__& a10,
+           const std::vector<T10__, Alloc10__>& a11,
+           const std::vector<T11__, Alloc11__>& a12, std::ostream* pstream__)  const 
 {
 return f12(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, pstream__);
 }
 };
 
-void
+inline void
 foo_6(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -8649,14 +8544,14 @@ foo_6(std::ostream* pstream__) {
 }
 
 struct foo_6_functor__ {
-void
+inline void
 operator()(std::ostream* pstream__)  const 
 {
 return foo_6(pstream__);
 }
 };
 
-Eigen::Matrix<double, -1, -1>
+inline Eigen::Matrix<double, -1, -1>
 matfoo(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -8678,14 +8573,14 @@ matfoo(std::ostream* pstream__) {
 }
 
 struct matfoo_functor__ {
-Eigen::Matrix<double, -1, -1>
+inline Eigen::Matrix<double, -1, -1>
 operator()(std::ostream* pstream__)  const 
 {
 return matfoo(pstream__);
 }
 };
 
-Eigen::Matrix<double, -1, 1>
+inline Eigen::Matrix<double, -1, 1>
 vecfoo(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -8704,7 +8599,7 @@ vecfoo(std::ostream* pstream__) {
 }
 
 struct vecfoo_functor__ {
-Eigen::Matrix<double, -1, 1>
+inline Eigen::Matrix<double, -1, 1>
 operator()(std::ostream* pstream__)  const 
 {
 return vecfoo(pstream__);
@@ -8712,9 +8607,9 @@ return vecfoo(pstream__);
 };
 
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<T0__>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, 1>
 vecmufoo(const T0__& mu, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -8737,7 +8632,7 @@ vecmufoo(const T0__& mu, std::ostream* pstream__) {
 
 struct vecmufoo_functor__ {
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<T0__>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, 1>
 operator()(const T0__& mu, std::ostream* pstream__)  const 
 {
 return vecmufoo(mu, pstream__);
@@ -8745,9 +8640,9 @@ return vecmufoo(mu, pstream__);
 };
 
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<T0__>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, 1>
 vecmubar(const T0__& mu, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -8772,22 +8667,21 @@ vecmubar(const T0__& mu, std::ostream* pstream__) {
 
 struct vecmubar_functor__ {
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<T0__>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, 1>
 operator()(const T0__& mu, std::ostream* pstream__)  const 
 {
 return vecmubar(mu, pstream__);
 }
 };
 
-template <typename T0__, typename T1__, typename T2__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>, stan::value_type_t<T1__>,
-T2__>, -1, 1>
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
 algebra_system(const T0__& x_arg__, const T1__& y_arg__,
-               const std::vector<T2__>& dat, const std::vector<int>& dat_int,
+               const std::vector<T2__, Alloc2__>& dat,
+               const std::vector<T3__, Alloc3__>& dat_int,
                std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>,
-          stan::value_type_t<T1__>,
-          T2__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__>;
   int current_statement__ = 0; 
   const auto& x = to_ref(x_arg__);
   const auto& y = to_ref(y_arg__);
@@ -8817,24 +8711,25 @@ algebra_system(const T0__& x_arg__, const T1__& y_arg__,
 }
 
 struct algebra_system_functor__ {
-template <typename T0__, typename T1__, typename T2__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>, stan::value_type_t<T1__>,
-T2__>, -1, 1>
-operator()(const T0__& x, const T1__& y, const std::vector<T2__>& dat,
-           const std::vector<int>& dat_int, std::ostream* pstream__)  const 
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
+operator()(const T0__& x, const T1__& y,
+           const std::vector<T2__, Alloc2__>& dat,
+           const std::vector<T3__, Alloc3__>& dat_int,
+           std::ostream* pstream__)  const 
 {
 return algebra_system(x, y, dat, dat_int, pstream__);
 }
 };
 
-template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>,
-stan::value_type_t<T1__>>, -1, 1>
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
 binomialf(const T0__& phi_arg__, const T1__& theta_arg__,
-          const std::vector<double>& x_r, const std::vector<int>& x_i,
-          std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>,
-          stan::value_type_t<T1__>>;
+          const std::vector<T2__, Alloc2__>& x_r,
+          const std::vector<T3__, Alloc3__>& x_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__>;
   int current_statement__ = 0; 
   const auto& phi = to_ref(phi_arg__);
   const auto& theta = to_ref(theta_arg__);
@@ -8858,12 +8753,12 @@ binomialf(const T0__& phi_arg__, const T1__& theta_arg__,
 }
 
 struct binomialf_functor__ {
-template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>,
-stan::value_type_t<T1__>>, -1, 1>
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
 operator()(const T0__& phi, const T1__& theta,
-           const std::vector<double>& x_r, const std::vector<int>& x_i,
-           std::ostream* pstream__)  const 
+           const std::vector<T2__, Alloc2__>& x_r,
+           const std::vector<T3__, Alloc3__>& x_i, std::ostream* pstream__)  const 
 {
 return binomialf(phi, theta, x_r, x_i, pstream__);
 }
@@ -14969,13 +14864,15 @@ static constexpr std::array<const char*, 158> locations_array__ =
  " (in 'motherHOF.stan', line 25, column 45 to line 30, column 3)"};
 
 
-template <typename T0__, typename T1__, typename T2__, typename T3__>
-std::vector<stan::promote_args_t<T0__, T1__, T2__,
-T3__>>
-sho(const T0__& t, const std::vector<T1__>& y,
-    const std::vector<T2__>& theta, const std::vector<T3__>& x,
-    const std::vector<int>& x_int, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T1__, T2__, T3__>;
+template <typename T0__, typename T1__, typename Alloc1__, typename T2__,
+typename Alloc2__, typename T3__, typename Alloc3__, typename T4__,
+typename Alloc4__>
+inline std::vector<stan::return_type_t<T0__, T1__, T2__, T3__, T4__>>
+sho(const T0__& t, const std::vector<T1__, Alloc1__>& y,
+    const std::vector<T2__, Alloc2__>& theta,
+    const std::vector<T3__, Alloc3__>& x,
+    const std::vector<T4__, Alloc4__>& x_int, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__, T4__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -15002,24 +14899,27 @@ sho(const T0__& t, const std::vector<T1__>& y,
 }
 
 struct sho_functor__ {
-template <typename T0__, typename T1__, typename T2__, typename T3__>
-std::vector<stan::promote_args_t<T0__, T1__, T2__,
-T3__>>
-operator()(const T0__& t, const std::vector<T1__>& y,
-           const std::vector<T2__>& theta, const std::vector<T3__>& x,
-           const std::vector<int>& x_int, std::ostream* pstream__)  const 
+template <typename T0__, typename T1__, typename Alloc1__, typename T2__,
+typename Alloc2__, typename T3__, typename Alloc3__, typename T4__,
+typename Alloc4__>
+inline std::vector<stan::return_type_t<T0__, T1__, T2__, T3__, T4__>>
+operator()(const T0__& t, const std::vector<T1__, Alloc1__>& y,
+           const std::vector<T2__, Alloc2__>& theta,
+           const std::vector<T3__, Alloc3__>& x,
+           const std::vector<T4__, Alloc4__>& x_int, std::ostream* pstream__)  const 
 {
 return sho(t, y, theta, x, x_int, pstream__);
 }
 };
 
-template <typename T0__, typename T1__, typename T2__, typename T3__>
-stan::promote_args_t<T0__, T1__, T2__,
-T3__>
-integrand(const T0__& x, const T1__& xc, const std::vector<T2__>& theta,
-          const std::vector<T3__>& x_r, const std::vector<int>& x_i,
-          std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T1__, T2__, T3__>;
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__, typename T4__, typename Alloc4__>
+inline auto
+integrand(const T0__& x, const T1__& xc,
+          const std::vector<T2__, Alloc2__>& theta,
+          const std::vector<T3__, Alloc3__>& x_r,
+          const std::vector<T4__, Alloc4__>& x_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__, T4__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -15035,26 +14935,25 @@ integrand(const T0__& x, const T1__& xc, const std::vector<T2__>& theta,
 }
 
 struct integrand_functor__ {
-template <typename T0__, typename T1__, typename T2__, typename T3__>
-stan::promote_args_t<T0__, T1__, T2__,
-T3__>
-operator()(const T0__& x, const T1__& xc, const std::vector<T2__>& theta,
-           const std::vector<T3__>& x_r, const std::vector<int>& x_i,
-           std::ostream* pstream__)  const 
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__, typename T4__, typename Alloc4__>
+inline auto
+operator()(const T0__& x, const T1__& xc,
+           const std::vector<T2__, Alloc2__>& theta,
+           const std::vector<T3__, Alloc3__>& x_r,
+           const std::vector<T4__, Alloc4__>& x_i, std::ostream* pstream__)  const 
 {
 return integrand(x, xc, theta, x_r, x_i, pstream__);
 }
 };
 
-template <typename T0__, typename T1__, typename T2__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>, stan::value_type_t<T1__>,
-T2__>, -1, 1>
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
 foo(const T0__& shared_params_arg__, const T1__& job_params_arg__,
-    const std::vector<T2__>& data_r, const std::vector<int>& data_i,
-    std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>,
-          stan::value_type_t<T1__>,
-          T2__>;
+    const std::vector<T2__, Alloc2__>& data_r,
+    const std::vector<T3__, Alloc3__>& data_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__>;
   int current_statement__ = 0; 
   const auto& shared_params = to_ref(shared_params_arg__);
   const auto& job_params = to_ref(job_params_arg__);
@@ -15072,26 +14971,24 @@ foo(const T0__& shared_params_arg__, const T1__& job_params_arg__,
 }
 
 struct foo_functor__ {
-template <typename T0__, typename T1__, typename T2__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>, stan::value_type_t<T1__>,
-T2__>, -1, 1>
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
 operator()(const T0__& shared_params, const T1__& job_params,
-           const std::vector<T2__>& data_r, const std::vector<int>& data_i,
-           std::ostream* pstream__)  const 
+           const std::vector<T2__, Alloc2__>& data_r,
+           const std::vector<T3__, Alloc3__>& data_i, std::ostream* pstream__)  const 
 {
 return foo(shared_params, job_params, data_r, data_i, pstream__);
 }
 };
 
-template <typename T0__, typename T1__, typename T2__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>, stan::value_type_t<T1__>,
-T2__>, -1, 1>
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
 goo(const T0__& shared_params_arg__, const T1__& job_params_arg__,
-    const std::vector<T2__>& data_r, const std::vector<int>& data_i,
-    std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>,
-          stan::value_type_t<T1__>,
-          T2__>;
+    const std::vector<T2__, Alloc2__>& data_r,
+    const std::vector<T3__, Alloc3__>& data_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__>;
   int current_statement__ = 0; 
   const auto& shared_params = to_ref(shared_params_arg__);
   const auto& job_params = to_ref(job_params_arg__);
@@ -15109,21 +15006,21 @@ goo(const T0__& shared_params_arg__, const T1__& job_params_arg__,
 }
 
 struct goo_functor__ {
-template <typename T0__, typename T1__, typename T2__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>, stan::value_type_t<T1__>,
-T2__>, -1, 1>
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
 operator()(const T0__& shared_params, const T1__& job_params,
-           const std::vector<T2__>& data_r, const std::vector<int>& data_i,
-           std::ostream* pstream__)  const 
+           const std::vector<T2__, Alloc2__>& data_r,
+           const std::vector<T3__, Alloc3__>& data_i, std::ostream* pstream__)  const 
 {
 return goo(shared_params, job_params, data_r, data_i, pstream__);
 }
 };
 
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 map_rectfake(const T0__& x, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -15140,22 +15037,21 @@ map_rectfake(const T0__& x, std::ostream* pstream__) {
 
 struct map_rectfake_functor__ {
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& x, std::ostream* pstream__)  const 
 {
 return map_rectfake(x, pstream__);
 }
 };
 
-template <typename T0__, typename T1__, typename T2__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>, stan::value_type_t<T1__>,
-T2__>, -1, 1>
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
 algebra_system(const T0__& x_arg__, const T1__& y_arg__,
-               const std::vector<T2__>& dat, const std::vector<int>& dat_int,
+               const std::vector<T2__, Alloc2__>& dat,
+               const std::vector<T3__, Alloc3__>& dat_int,
                std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>,
-          stan::value_type_t<T1__>,
-          T2__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__>;
   int current_statement__ = 0; 
   const auto& x = to_ref(x_arg__);
   const auto& y = to_ref(y_arg__);
@@ -15185,11 +15081,13 @@ algebra_system(const T0__& x_arg__, const T1__& y_arg__,
 }
 
 struct algebra_system_functor__ {
-template <typename T0__, typename T1__, typename T2__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>, stan::value_type_t<T1__>,
-T2__>, -1, 1>
-operator()(const T0__& x, const T1__& y, const std::vector<T2__>& dat,
-           const std::vector<int>& dat_int, std::ostream* pstream__)  const 
+template <typename T0__, typename T1__, typename T2__, typename Alloc2__,
+typename T3__, typename Alloc3__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
+operator()(const T0__& x, const T1__& y,
+           const std::vector<T2__, Alloc2__>& dat,
+           const std::vector<T3__, Alloc3__>& dat_int,
+           std::ostream* pstream__)  const 
 {
 return algebra_system(x, y, dat, dat_int, pstream__);
 }
@@ -17472,14 +17370,10 @@ static constexpr std::array<const char*, 630> locations_array__ =
 
 
 template <typename T0__, typename T1__, typename T2__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<T0__, stan::value_type_t<T1__>, T2__,
-stan::value_type_t<T3__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
 f(const T0__& t, const T1__& z_arg__, const T2__& a, const T3__& b_arg__,
   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__,
-          stan::value_type_t<T1__>,
-          T2__,
-          stan::value_type_t<T3__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__>;
   int current_statement__ = 0; 
   const auto& z = to_ref(z_arg__);
   const auto& b = to_ref(b_arg__);
@@ -17498,8 +17392,7 @@ f(const T0__& t, const T1__& z_arg__, const T2__& a, const T3__& b_arg__,
 
 struct f_functor__ {
 template <typename T0__, typename T1__, typename T2__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<T0__, stan::value_type_t<T1__>, T2__,
-stan::value_type_t<T3__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
 operator()(const T0__& t, const T1__& z, const T2__& a, const T3__& b,
            std::ostream* pstream__)  const 
 {
@@ -17510,8 +17403,7 @@ return f(t, z, a, b, pstream__);
 
 struct f_odefunctor__ {
 template <typename T0__, typename T1__, typename T2__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<T0__, stan::value_type_t<T1__>, T2__,
-stan::value_type_t<T3__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, 1>
 operator()(const T0__& t, const T1__& z, std::ostream* pstream__,
            const T2__& a, const T3__& b)  const 
 {
@@ -20923,13 +20815,15 @@ static constexpr std::array<const char*, 35> locations_array__ =
  " (in 'old_integrate_interface.stan', line 7, column 38 to line 19, column 3)"};
 
 
-template <typename T0__, typename T1__, typename T2__, typename T3__>
-std::vector<stan::promote_args_t<T0__, T1__, T2__,
-T3__>>
-dz_dt(const T0__& t, const std::vector<T1__>& z,
-      const std::vector<T2__>& theta, const std::vector<T3__>& x_r,
-      const std::vector<int>& x_i, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T1__, T2__, T3__>;
+template <typename T0__, typename T1__, typename Alloc1__, typename T2__,
+typename Alloc2__, typename T3__, typename Alloc3__, typename T4__,
+typename Alloc4__>
+inline std::vector<stan::return_type_t<T0__, T1__, T2__, T3__, T4__>>
+dz_dt(const T0__& t, const std::vector<T1__, Alloc1__>& z,
+      const std::vector<T2__, Alloc2__>& theta,
+      const std::vector<T3__, Alloc3__>& x_r,
+      const std::vector<T4__, Alloc4__>& x_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__, T4__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -20985,12 +20879,14 @@ dz_dt(const T0__& t, const std::vector<T1__>& z,
 }
 
 struct dz_dt_functor__ {
-template <typename T0__, typename T1__, typename T2__, typename T3__>
-std::vector<stan::promote_args_t<T0__, T1__, T2__,
-T3__>>
-operator()(const T0__& t, const std::vector<T1__>& z,
-           const std::vector<T2__>& theta, const std::vector<T3__>& x_r,
-           const std::vector<int>& x_i, std::ostream* pstream__)  const 
+template <typename T0__, typename T1__, typename Alloc1__, typename T2__,
+typename Alloc2__, typename T3__, typename Alloc3__, typename T4__,
+typename Alloc4__>
+inline std::vector<stan::return_type_t<T0__, T1__, T2__, T3__, T4__>>
+operator()(const T0__& t, const std::vector<T1__, Alloc1__>& z,
+           const std::vector<T2__, Alloc2__>& theta,
+           const std::vector<T3__, Alloc3__>& x_r,
+           const std::vector<T4__, Alloc4__>& x_i, std::ostream* pstream__)  const 
 {
 return dz_dt(t, z, theta, x_r, x_i, pstream__);
 }
@@ -24015,11 +23911,11 @@ struct g_rsfunctor__;
 struct h_rsfunctor__;
 template <bool propto__>
 struct foo_lpdf_rsfunctor__;
-template <typename T0__>
-stan::promote_args_t<T0__>
-g(const std::vector<T0__>& y_slice, const int& start, const int& end,
-  std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+g(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+  const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -24041,9 +23937,9 @@ g(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return g(y_slice, start, end, pstream__);
@@ -24052,21 +23948,21 @@ return g(y_slice, start, end, pstream__);
 
 
 struct g_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return g(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-h(const std::vector<T0__>& y_slice, const int& start, const int& end,
-  const std::vector<T3__>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+h(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+  const int& end, const std::vector<T3__, Alloc3__>& a,
+  std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -24089,11 +23985,10 @@ h(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct h_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
-           const int& end, const std::vector<T3__>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return h(y_slice, start, end, a, pstream__);
@@ -24102,22 +23997,21 @@ return h(y_slice, start, end, a, pstream__);
 
 
 struct h_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__,
-           const std::vector<T3__>& a)  const 
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return h(y_slice, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <bool propto__, typename T0__>
-stan::promote_args_t<T0__>
-foo_lpdf(const std::vector<T0__>& y_slice, const int& start, const int& end,
-         std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <bool propto__, typename T0__, typename Alloc0__>
+inline auto
+foo_lpdf(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+         const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -24131,9 +24025,9 @@ foo_lpdf(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct foo_lpdf_functor__ {
-template <bool propto__, typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <bool propto__, typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return foo_lpdf<propto__>(y_slice, start, end, pstream__);
@@ -24143,9 +24037,9 @@ return foo_lpdf<propto__>(y_slice, start, end, pstream__);
 
 template <bool propto__>
 struct foo_lpdf_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return foo_lpdf<propto__>(y_slice, start + 1, end + 1, pstream__);
@@ -24773,11 +24667,11 @@ struct h5_rsfunctor__;
 struct h6_rsfunctor__;
 struct h7_rsfunctor__;
 struct h8_rsfunctor__;
-template <typename T0__>
-stan::promote_args_t<T0__>
-g1(const std::vector<T0__>& y_slice, const int& start, const int& end,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+g1(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -24793,9 +24687,9 @@ g1(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g1_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return g1(y_slice, start, end, pstream__);
@@ -24804,20 +24698,20 @@ return g1(y_slice, start, end, pstream__);
 
 
 struct g1_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return g1(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-g2(const std::vector<Eigen::Matrix<T0__, -1, 1>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+g2(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
    const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -24845,10 +24739,10 @@ g2(const std::vector<Eigen::Matrix<T0__, -1, 1>>& y_slice, const int& start,
 }
 
 struct g2_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<Eigen::Matrix<T0__, -1, 1>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return g2(y_slice, start, end, pstream__);
 }
@@ -24856,20 +24750,20 @@ return g2(y_slice, start, end, pstream__);
 
 
 struct g2_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<Eigen::Matrix<T0__, -1, 1>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return g2(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-g3(const std::vector<Eigen::Matrix<T0__, 1, -1>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+g3(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
    const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -24897,10 +24791,10 @@ g3(const std::vector<Eigen::Matrix<T0__, 1, -1>>& y_slice, const int& start,
 }
 
 struct g3_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<Eigen::Matrix<T0__, 1, -1>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return g3(y_slice, start, end, pstream__);
 }
@@ -24908,20 +24802,20 @@ return g3(y_slice, start, end, pstream__);
 
 
 struct g3_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<Eigen::Matrix<T0__, 1, -1>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return g3(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-g4(const std::vector<Eigen::Matrix<T0__, -1, -1>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+g4(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
    const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -24950,10 +24844,10 @@ g4(const std::vector<Eigen::Matrix<T0__, -1, -1>>& y_slice, const int& start,
 }
 
 struct g4_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<Eigen::Matrix<T0__, -1, -1>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return g4(y_slice, start, end, pstream__);
 }
@@ -24961,20 +24855,20 @@ return g4(y_slice, start, end, pstream__);
 
 
 struct g4_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<Eigen::Matrix<T0__, -1, -1>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return g4(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-g5(const std::vector<std::vector<T0__>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+g5(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
    const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -25007,9 +24901,9 @@ g5(const std::vector<std::vector<T0__>>& y_slice, const int& start,
 }
 
 struct g5_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<T0__>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return g5(y_slice, start, end, pstream__);
@@ -25018,20 +24912,20 @@ return g5(y_slice, start, end, pstream__);
 
 
 struct g5_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<T0__>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return g5(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-g6(const std::vector<std::vector<Eigen::Matrix<T0__, -1, 1>>>& y_slice,
-   const int& start, const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+g6(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -25065,10 +24959,10 @@ g6(const std::vector<std::vector<Eigen::Matrix<T0__, -1, 1>>>& y_slice,
 }
 
 struct g6_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<Eigen::Matrix<T0__, -1, 1>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return g6(y_slice, start, end, pstream__);
 }
@@ -25076,20 +24970,20 @@ return g6(y_slice, start, end, pstream__);
 
 
 struct g6_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<Eigen::Matrix<T0__, -1, 1>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return g6(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-g7(const std::vector<std::vector<Eigen::Matrix<T0__, 1, -1>>>& y_slice,
-   const int& start, const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+g7(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -25123,10 +25017,10 @@ g7(const std::vector<std::vector<Eigen::Matrix<T0__, 1, -1>>>& y_slice,
 }
 
 struct g7_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<Eigen::Matrix<T0__, 1, -1>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return g7(y_slice, start, end, pstream__);
 }
@@ -25134,20 +25028,20 @@ return g7(y_slice, start, end, pstream__);
 
 
 struct g7_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<Eigen::Matrix<T0__, 1, -1>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return g7(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-g8(const std::vector<std::vector<Eigen::Matrix<T0__, -1, -1>>>& y_slice,
-   const int& start, const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+g8(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -25181,10 +25075,10 @@ g8(const std::vector<std::vector<Eigen::Matrix<T0__, -1, -1>>>& y_slice,
 }
 
 struct g8_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<Eigen::Matrix<T0__, -1, -1>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return g8(y_slice, start, end, pstream__);
 }
@@ -25192,21 +25086,20 @@ return g8(y_slice, start, end, pstream__);
 
 
 struct g8_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<Eigen::Matrix<T0__, -1, -1>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return g8(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-h1(const std::vector<T0__>& y, const int& start, const int& end,
-   const std::vector<T3__>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+h1(const std::vector<T0__, Alloc0__>& y, const int& start, const int& end,
+   const std::vector<T3__, Alloc3__>& a, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -25223,11 +25116,11 @@ h1(const std::vector<T0__>& y, const int& start, const int& end,
 }
 
 struct h1_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           const std::vector<T3__>& a, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
+           std::ostream* pstream__)  const 
 {
 return h1(y, start, end, a, pstream__);
 }
@@ -25235,22 +25128,21 @@ return h1(y, start, end, a, pstream__);
 
 
 struct h1_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           std::ostream* pstream__, const std::vector<T3__>& a)  const 
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, std::ostream* pstream__,
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return h1(y, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-h2(const std::vector<T0__>& y, const int& start, const int& end,
-   const std::vector<Eigen::Matrix<T3__, -1, 1>>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+h2(const std::vector<T0__, Alloc0__>& y, const int& start, const int& end,
+   const std::vector<T3__, Alloc3__>& a, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -25277,11 +25169,10 @@ h2(const std::vector<T0__>& y, const int& start, const int& end,
 }
 
 struct h2_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           const std::vector<Eigen::Matrix<T3__, -1, 1>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return h2(y, start, end, a, pstream__);
@@ -25290,23 +25181,21 @@ return h2(y, start, end, a, pstream__);
 
 
 struct h2_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           std::ostream* pstream__,
-           const std::vector<Eigen::Matrix<T3__, -1, 1>>& a)  const 
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, std::ostream* pstream__,
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return h2(y, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-h3(const std::vector<T0__>& y, const int& start, const int& end,
-   const std::vector<Eigen::Matrix<T3__, 1, -1>>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+h3(const std::vector<T0__, Alloc0__>& y, const int& start, const int& end,
+   const std::vector<T3__, Alloc3__>& a, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -25333,11 +25222,10 @@ h3(const std::vector<T0__>& y, const int& start, const int& end,
 }
 
 struct h3_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           const std::vector<Eigen::Matrix<T3__, 1, -1>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return h3(y, start, end, a, pstream__);
@@ -25346,23 +25234,21 @@ return h3(y, start, end, a, pstream__);
 
 
 struct h3_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           std::ostream* pstream__,
-           const std::vector<Eigen::Matrix<T3__, 1, -1>>& a)  const 
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, std::ostream* pstream__,
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return h3(y, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-h4(const std::vector<T0__>& y, const int& start, const int& end,
-   const std::vector<Eigen::Matrix<T3__, -1, -1>>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+h4(const std::vector<T0__, Alloc0__>& y, const int& start, const int& end,
+   const std::vector<T3__, Alloc3__>& a, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -25390,11 +25276,10 @@ h4(const std::vector<T0__>& y, const int& start, const int& end,
 }
 
 struct h4_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           const std::vector<Eigen::Matrix<T3__, -1, -1>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return h4(y, start, end, a, pstream__);
@@ -25403,23 +25288,21 @@ return h4(y, start, end, a, pstream__);
 
 
 struct h4_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           std::ostream* pstream__,
-           const std::vector<Eigen::Matrix<T3__, -1, -1>>& a)  const 
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, std::ostream* pstream__,
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return h4(y, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-h5(const std::vector<T0__>& y, const int& start, const int& end,
-   const std::vector<std::vector<T3__>>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+h5(const std::vector<T0__, Alloc0__>& y, const int& start, const int& end,
+   const std::vector<T3__, Alloc3__>& a, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -25450,11 +25333,11 @@ h5(const std::vector<T0__>& y, const int& start, const int& end,
 }
 
 struct h5_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           const std::vector<std::vector<T3__>>& a, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
+           std::ostream* pstream__)  const 
 {
 return h5(y, start, end, a, pstream__);
 }
@@ -25462,23 +25345,21 @@ return h5(y, start, end, a, pstream__);
 
 
 struct h5_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           std::ostream* pstream__, const std::vector<std::vector<T3__>>& a)  const 
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, std::ostream* pstream__,
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return h5(y, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-h6(const std::vector<T0__>& y, const int& start, const int& end,
-   const std::vector<std::vector<Eigen::Matrix<T3__, -1, 1>>>& a,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+h6(const std::vector<T0__, Alloc0__>& y, const int& start, const int& end,
+   const std::vector<T3__, Alloc3__>& a, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -25510,11 +25391,10 @@ h6(const std::vector<T0__>& y, const int& start, const int& end,
 }
 
 struct h6_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           const std::vector<std::vector<Eigen::Matrix<T3__, -1, 1>>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return h6(y, start, end, a, pstream__);
@@ -25523,24 +25403,21 @@ return h6(y, start, end, a, pstream__);
 
 
 struct h6_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           std::ostream* pstream__,
-           const std::vector<std::vector<Eigen::Matrix<T3__, -1, 1>>>& a)  const 
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, std::ostream* pstream__,
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return h6(y, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-h7(const std::vector<T0__>& y, const int& start, const int& end,
-   const std::vector<std::vector<Eigen::Matrix<T3__, 1, -1>>>& a,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+h7(const std::vector<T0__, Alloc0__>& y, const int& start, const int& end,
+   const std::vector<T3__, Alloc3__>& a, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -25572,11 +25449,10 @@ h7(const std::vector<T0__>& y, const int& start, const int& end,
 }
 
 struct h7_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           const std::vector<std::vector<Eigen::Matrix<T3__, 1, -1>>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return h7(y, start, end, a, pstream__);
@@ -25585,24 +25461,21 @@ return h7(y, start, end, a, pstream__);
 
 
 struct h7_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           std::ostream* pstream__,
-           const std::vector<std::vector<Eigen::Matrix<T3__, 1, -1>>>& a)  const 
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, std::ostream* pstream__,
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return h7(y, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-h8(const std::vector<T0__>& y, const int& start, const int& end,
-   const std::vector<std::vector<Eigen::Matrix<T3__, -1, -1>>>& a,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+h8(const std::vector<T0__, Alloc0__>& y, const int& start, const int& end,
+   const std::vector<T3__, Alloc3__>& a, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -25634,11 +25507,10 @@ h8(const std::vector<T0__>& y, const int& start, const int& end,
 }
 
 struct h8_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           const std::vector<std::vector<Eigen::Matrix<T3__, -1, -1>>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return h8(y, start, end, a, pstream__);
@@ -25647,12 +25519,11 @@ return h8(y, start, end, a, pstream__);
 
 
 struct h8_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y, const int& start, const int& end,
-           std::ostream* pstream__,
-           const std::vector<std::vector<Eigen::Matrix<T3__, -1, -1>>>& a)  const 
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y, const int& start,
+           const int& end, std::ostream* pstream__,
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return h8(y, start + 1, end + 1, a, pstream__);
 }
@@ -27377,11 +27248,11 @@ struct g7_rsfunctor__;
 struct g8_rsfunctor__;
 struct g9_rsfunctor__;
 struct s_rsfunctor__;
-template <typename T0__>
-stan::promote_args_t<T0__>
-f1(const std::vector<T0__>& y_slice, const int& start, const int& end,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+f1(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27397,9 +27268,9 @@ f1(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct f1_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return f1(y_slice, start, end, pstream__);
@@ -27408,20 +27279,20 @@ return f1(y_slice, start, end, pstream__);
 
 
 struct f1_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return f1(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-f1a(const std::vector<T0__>& y_slice, const int& start, const int& end,
-    std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+f1a(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+    const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27437,9 +27308,9 @@ f1a(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct f1a_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return f1a(y_slice, start, end, pstream__);
@@ -27448,20 +27319,20 @@ return f1a(y_slice, start, end, pstream__);
 
 
 struct f1a_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return f1a(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-f2(const std::vector<Eigen::Matrix<T0__, -1, 1>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+f2(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
    const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27477,10 +27348,10 @@ f2(const std::vector<Eigen::Matrix<T0__, -1, 1>>& y_slice, const int& start,
 }
 
 struct f2_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<Eigen::Matrix<T0__, -1, 1>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f2(y_slice, start, end, pstream__);
 }
@@ -27488,20 +27359,20 @@ return f2(y_slice, start, end, pstream__);
 
 
 struct f2_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<Eigen::Matrix<T0__, -1, 1>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f2(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-f3(const std::vector<Eigen::Matrix<T0__, 1, -1>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+f3(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
    const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27517,10 +27388,10 @@ f3(const std::vector<Eigen::Matrix<T0__, 1, -1>>& y_slice, const int& start,
 }
 
 struct f3_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<Eigen::Matrix<T0__, 1, -1>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f3(y_slice, start, end, pstream__);
 }
@@ -27528,20 +27399,20 @@ return f3(y_slice, start, end, pstream__);
 
 
 struct f3_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<Eigen::Matrix<T0__, 1, -1>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f3(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-f4(const std::vector<Eigen::Matrix<T0__, -1, -1>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+f4(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
    const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27557,10 +27428,10 @@ f4(const std::vector<Eigen::Matrix<T0__, -1, -1>>& y_slice, const int& start,
 }
 
 struct f4_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<Eigen::Matrix<T0__, -1, -1>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f4(y_slice, start, end, pstream__);
 }
@@ -27568,20 +27439,20 @@ return f4(y_slice, start, end, pstream__);
 
 
 struct f4_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<Eigen::Matrix<T0__, -1, -1>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f4(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-f5(const std::vector<std::vector<T0__>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+f5(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
    const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27597,9 +27468,9 @@ f5(const std::vector<std::vector<T0__>>& y_slice, const int& start,
 }
 
 struct f5_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<T0__>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return f5(y_slice, start, end, pstream__);
@@ -27608,20 +27479,20 @@ return f5(y_slice, start, end, pstream__);
 
 
 struct f5_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<T0__>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return f5(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-f6(const std::vector<std::vector<Eigen::Matrix<T0__, -1, 1>>>& y_slice,
-   const int& start, const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+f6(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27637,10 +27508,10 @@ f6(const std::vector<std::vector<Eigen::Matrix<T0__, -1, 1>>>& y_slice,
 }
 
 struct f6_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<Eigen::Matrix<T0__, -1, 1>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f6(y_slice, start, end, pstream__);
 }
@@ -27648,20 +27519,20 @@ return f6(y_slice, start, end, pstream__);
 
 
 struct f6_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<Eigen::Matrix<T0__, -1, 1>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f6(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-f7(const std::vector<std::vector<Eigen::Matrix<T0__, 1, -1>>>& y_slice,
-   const int& start, const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+f7(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27677,10 +27548,10 @@ f7(const std::vector<std::vector<Eigen::Matrix<T0__, 1, -1>>>& y_slice,
 }
 
 struct f7_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<Eigen::Matrix<T0__, 1, -1>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f7(y_slice, start, end, pstream__);
 }
@@ -27688,20 +27559,20 @@ return f7(y_slice, start, end, pstream__);
 
 
 struct f7_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<Eigen::Matrix<T0__, 1, -1>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f7(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-f8(const std::vector<std::vector<Eigen::Matrix<T0__, -1, -1>>>& y_slice,
-   const int& start, const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+f8(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27717,10 +27588,10 @@ f8(const std::vector<std::vector<Eigen::Matrix<T0__, -1, -1>>>& y_slice,
 }
 
 struct f8_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<Eigen::Matrix<T0__, -1, -1>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f8(y_slice, start, end, pstream__);
 }
@@ -27728,19 +27599,20 @@ return f8(y_slice, start, end, pstream__);
 
 
 struct f8_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<Eigen::Matrix<T0__, -1, -1>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f8(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-double
-f9(const std::vector<int>& y_slice, const int& start, const int& end,
-   std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline auto
+f9(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27756,9 +27628,10 @@ f9(const std::vector<int>& y_slice, const int& start, const int& end,
 }
 
 struct f9_functor__ {
-double
-operator()(const std::vector<int>& y_slice, const int& start, const int& end,
-           std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f9(y_slice, start, end, pstream__);
 }
@@ -27766,18 +27639,20 @@ return f9(y_slice, start, end, pstream__);
 
 
 struct f9_rsfunctor__ {
-double
-operator()(const std::vector<int>& y_slice, const int& start, const int& end,
-           std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f9(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-double
-f10(const std::vector<std::vector<int>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+f10(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
     const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27793,8 +27668,9 @@ f10(const std::vector<std::vector<int>>& y_slice, const int& start,
 }
 
 struct f10_functor__ {
-double
-operator()(const std::vector<std::vector<int>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return f10(y_slice, start, end, pstream__);
@@ -27803,18 +27679,20 @@ return f10(y_slice, start, end, pstream__);
 
 
 struct f10_rsfunctor__ {
-double
-operator()(const std::vector<std::vector<int>>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__)  const 
 {
 return f10(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-double
-f11(const std::vector<std::vector<std::vector<int>>>& y_slice,
-    const int& start, const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline auto
+f11(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+    const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27830,9 +27708,10 @@ f11(const std::vector<std::vector<std::vector<int>>>& y_slice,
 }
 
 struct f11_functor__ {
-double
-operator()(const std::vector<std::vector<std::vector<int>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f11(y_slice, start, end, pstream__);
 }
@@ -27840,19 +27719,20 @@ return f11(y_slice, start, end, pstream__);
 
 
 struct f11_rsfunctor__ {
-double
-operator()(const std::vector<std::vector<std::vector<int>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f11(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-f12(const std::vector<std::vector<std::vector<T0__>>>& y_slice,
-    const int& start, const int& end, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+f12(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+    const int& end, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27868,10 +27748,10 @@ f12(const std::vector<std::vector<std::vector<T0__>>>& y_slice,
 }
 
 struct f12_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<std::vector<T0__>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f12(y_slice, start, end, pstream__);
 }
@@ -27879,21 +27759,20 @@ return f12(y_slice, start, end, pstream__);
 
 
 struct f12_rsfunctor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<std::vector<std::vector<T0__>>>& y_slice,
-           const int& start, const int& end, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, std::ostream* pstream__)  const 
 {
 return f12(y_slice, start + 1, end + 1, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-g1(const std::vector<T0__>& y_slice, const int& start, const int& end,
-   const T3__& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__>
+inline auto
+g1(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, const T3__& a, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -27909,10 +27788,9 @@ g1(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g1_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, const T3__& a, std::ostream* pstream__)  const 
 {
 return g1(y_slice, start, end, a, pstream__);
@@ -27921,23 +27799,20 @@ return g1(y_slice, start, end, a, pstream__);
 
 
 struct g1_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__, const T3__& a)  const 
 {
 return g1(y_slice, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-stan::value_type_t<T3__>>
-g2(const std::vector<T0__>& y_slice, const int& start, const int& end,
-   const T3__& a_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__,
-          stan::value_type_t<T3__>>;
+template <typename T0__, typename Alloc0__, typename T3__>
+inline auto
+g2(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, const T3__& a_arg__, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   const auto& a = to_ref(a_arg__);
   static constexpr bool propto__ = true;
@@ -27954,10 +27829,9 @@ g2(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g2_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-stan::value_type_t<T3__>>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, const T3__& a, std::ostream* pstream__)  const 
 {
 return g2(y_slice, start, end, a, pstream__);
@@ -27966,23 +27840,20 @@ return g2(y_slice, start, end, a, pstream__);
 
 
 struct g2_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-stan::value_type_t<T3__>>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__, const T3__& a)  const 
 {
 return g2(y_slice, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-stan::value_type_t<T3__>>
-g3(const std::vector<T0__>& y_slice, const int& start, const int& end,
-   const T3__& a_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__,
-          stan::value_type_t<T3__>>;
+template <typename T0__, typename Alloc0__, typename T3__>
+inline auto
+g3(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, const T3__& a_arg__, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   const auto& a = to_ref(a_arg__);
   static constexpr bool propto__ = true;
@@ -27999,10 +27870,9 @@ g3(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g3_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-stan::value_type_t<T3__>>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, const T3__& a, std::ostream* pstream__)  const 
 {
 return g3(y_slice, start, end, a, pstream__);
@@ -28011,23 +27881,20 @@ return g3(y_slice, start, end, a, pstream__);
 
 
 struct g3_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-stan::value_type_t<T3__>>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__, const T3__& a)  const 
 {
 return g3(y_slice, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-stan::value_type_t<T3__>>
-g4(const std::vector<T0__>& y_slice, const int& start, const int& end,
-   const T3__& a_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__,
-          stan::value_type_t<T3__>>;
+template <typename T0__, typename Alloc0__, typename T3__>
+inline auto
+g4(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, const T3__& a_arg__, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   const auto& a = to_ref(a_arg__);
   static constexpr bool propto__ = true;
@@ -28044,10 +27911,9 @@ g4(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g4_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-stan::value_type_t<T3__>>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, const T3__& a, std::ostream* pstream__)  const 
 {
 return g4(y_slice, start, end, a, pstream__);
@@ -28056,22 +27922,21 @@ return g4(y_slice, start, end, a, pstream__);
 
 
 struct g4_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-stan::value_type_t<T3__>>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__, const T3__& a)  const 
 {
 return g4(y_slice, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-g5(const std::vector<T0__>& y_slice, const int& start, const int& end,
-   const std::vector<T3__>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+g5(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, const std::vector<T3__, Alloc3__>& a,
+   std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -28087,11 +27952,10 @@ g5(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g5_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
-           const int& end, const std::vector<T3__>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return g5(y_slice, start, end, a, pstream__);
@@ -28100,23 +27964,22 @@ return g5(y_slice, start, end, a, pstream__);
 
 
 struct g5_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__,
-           const std::vector<T3__>& a)  const 
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return g5(y_slice, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-g6(const std::vector<T0__>& y_slice, const int& start, const int& end,
-   const std::vector<Eigen::Matrix<T3__, -1, 1>>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+g6(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, const std::vector<T3__, Alloc3__>& a,
+   std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -28132,11 +27995,10 @@ g6(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g6_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
-           const int& end, const std::vector<Eigen::Matrix<T3__, -1, 1>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return g6(y_slice, start, end, a, pstream__);
@@ -28145,23 +28007,22 @@ return g6(y_slice, start, end, a, pstream__);
 
 
 struct g6_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__,
-           const std::vector<Eigen::Matrix<T3__, -1, 1>>& a)  const 
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return g6(y_slice, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-g7(const std::vector<T0__>& y_slice, const int& start, const int& end,
-   const std::vector<Eigen::Matrix<T3__, 1, -1>>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+g7(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, const std::vector<T3__, Alloc3__>& a,
+   std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -28177,11 +28038,10 @@ g7(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g7_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
-           const int& end, const std::vector<Eigen::Matrix<T3__, 1, -1>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return g7(y_slice, start, end, a, pstream__);
@@ -28190,23 +28050,22 @@ return g7(y_slice, start, end, a, pstream__);
 
 
 struct g7_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__,
-           const std::vector<Eigen::Matrix<T3__, 1, -1>>& a)  const 
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return g7(y_slice, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-g8(const std::vector<T0__>& y_slice, const int& start, const int& end,
-   const std::vector<Eigen::Matrix<T3__, -1, -1>>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+g8(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, const std::vector<T3__, Alloc3__>& a,
+   std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -28222,11 +28081,10 @@ g8(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g8_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
-           const int& end, const std::vector<Eigen::Matrix<T3__, -1, -1>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return g8(y_slice, start, end, a, pstream__);
@@ -28235,23 +28093,22 @@ return g8(y_slice, start, end, a, pstream__);
 
 
 struct g8_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__,
-           const std::vector<Eigen::Matrix<T3__, -1, -1>>& a)  const 
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return g8(y_slice, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-g9(const std::vector<T0__>& y_slice, const int& start, const int& end,
-   const std::vector<std::vector<T3__>>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+g9(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+   const int& end, const std::vector<T3__, Alloc3__>& a,
+   std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -28267,11 +28124,10 @@ g9(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g9_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
-           const int& end, const std::vector<std::vector<T3__>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return g9(y_slice, start, end, a, pstream__);
@@ -28280,24 +28136,22 @@ return g9(y_slice, start, end, a, pstream__);
 
 
 struct g9_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__,
-           const std::vector<std::vector<T3__>>& a)  const 
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return g9(y_slice, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-g10(const std::vector<T0__>& y_slice, const int& start, const int& end,
-    const std::vector<std::vector<Eigen::Matrix<T3__, -1, 1>>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+g10(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+    const int& end, const std::vector<T3__, Alloc3__>& a,
     std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -28313,12 +28167,10 @@ g10(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g10_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
-           const int& end,
-           const std::vector<std::vector<Eigen::Matrix<T3__, -1, 1>>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return g10(y_slice, start, end, a, pstream__);
@@ -28327,24 +28179,22 @@ return g10(y_slice, start, end, a, pstream__);
 
 
 struct g10_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__,
-           const std::vector<std::vector<Eigen::Matrix<T3__, -1, 1>>>& a)  const 
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return g10(y_slice, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-g11(const std::vector<T0__>& y_slice, const int& start, const int& end,
-    const std::vector<std::vector<Eigen::Matrix<T3__, 1, -1>>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+g11(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+    const int& end, const std::vector<T3__, Alloc3__>& a,
     std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -28360,12 +28210,10 @@ g11(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g11_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
-           const int& end,
-           const std::vector<std::vector<Eigen::Matrix<T3__, 1, -1>>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return g11(y_slice, start, end, a, pstream__);
@@ -28374,24 +28222,22 @@ return g11(y_slice, start, end, a, pstream__);
 
 
 struct g11_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__,
-           const std::vector<std::vector<Eigen::Matrix<T3__, 1, -1>>>& a)  const 
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return g11(y_slice, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-g12(const std::vector<T0__>& y_slice, const int& start, const int& end,
-    const std::vector<std::vector<Eigen::Matrix<T3__, -1, -1>>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+g12(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+    const int& end, const std::vector<T3__, Alloc3__>& a,
     std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T3__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T3__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -28407,12 +28253,10 @@ g12(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct g12_functor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
-           const int& end,
-           const std::vector<std::vector<Eigen::Matrix<T3__, -1, -1>>>& a,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+           const int& end, const std::vector<T3__, Alloc3__>& a,
            std::ostream* pstream__)  const 
 {
 return g12(y_slice, start, end, a, pstream__);
@@ -28421,52 +28265,40 @@ return g12(y_slice, start, end, a, pstream__);
 
 
 struct g12_rsfunctor__ {
-template <typename T0__, typename T3__>
-stan::promote_args_t<T0__,
-T3__>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T3__, typename Alloc3__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__,
-           const std::vector<std::vector<Eigen::Matrix<T3__, -1, -1>>>& a)  const 
+           const std::vector<T3__, Alloc3__>& a)  const 
 {
 return g12(y_slice, start + 1, end + 1, a, pstream__);
 }
 };
 
-template <typename T0__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T9__, typename T10__, typename T11__, typename T12__,
-typename T14__, typename T15__, typename T16__, typename T17__,
-typename T19__>
-stan::promote_args_t<T0__, T4__, stan::value_type_t<T5__>,
-stan::value_type_t<T6__>,
-stan::value_type_t<T7__>, stan::promote_args_t<T9__, T10__, T11__, T12__,
-T14__, stan::promote_args_t<T15__, T16__, T17__,
-T19__>>>
-s(const std::vector<T0__>& y_slice, const int& start, const int& end,
-  const int& a, const T4__& b, const T5__& c_arg__, const T6__& d_arg__,
-  const T7__& e_arg__, const std::vector<int>& f, const std::vector<T9__>& g,
-  const std::vector<Eigen::Matrix<T10__, -1, 1>>& h,
-  const std::vector<Eigen::Matrix<T11__, 1, -1>>& i,
-  const std::vector<Eigen::Matrix<T12__, -1, -1>>& j,
-  const std::vector<std::vector<int>>& k,
-  const std::vector<std::vector<T14__>>& l,
-  const std::vector<std::vector<Eigen::Matrix<T15__, -1, 1>>>& m,
-  const std::vector<std::vector<Eigen::Matrix<T16__, 1, -1>>>& n,
-  const std::vector<std::vector<Eigen::Matrix<T17__, -1, -1>>>& o,
-  const std::vector<std::vector<std::vector<int>>>& p,
-  const std::vector<std::vector<std::vector<T19__>>>& q,
-  std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__,
-          T4__,
-          stan::value_type_t<T5__>,
-          stan::value_type_t<T6__>,
-          stan::value_type_t<T7__>, stan::promote_args_t<T9__,
-          T10__,
-          T11__,
-          T12__,
-          T14__, stan::promote_args_t<T15__,
-          T16__,
-          T17__,
-          T19__>>>;
+template <typename T0__, typename Alloc0__, typename T4__, typename T5__,
+typename T6__, typename T7__, typename T8__, typename Alloc8__,
+typename T9__, typename Alloc9__, typename T10__, typename Alloc10__,
+typename T11__, typename Alloc11__, typename T12__, typename Alloc12__,
+typename T13__, typename Alloc13__, typename T14__, typename Alloc14__,
+typename T15__, typename Alloc15__, typename T16__, typename Alloc16__,
+typename T17__, typename Alloc17__, typename T18__, typename Alloc18__,
+typename T19__, typename Alloc19__>
+inline auto
+s(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
+  const int& end, const int& a, const T4__& b, const T5__& c_arg__,
+  const T6__& d_arg__, const T7__& e_arg__,
+  const std::vector<T8__, Alloc8__>& f, const std::vector<T9__, Alloc9__>& g,
+  const std::vector<T10__, Alloc10__>& h,
+  const std::vector<T11__, Alloc11__>& i,
+  const std::vector<T12__, Alloc12__>& j,
+  const std::vector<T13__, Alloc13__>& k,
+  const std::vector<T14__, Alloc14__>& l,
+  const std::vector<T15__, Alloc15__>& m,
+  const std::vector<T16__, Alloc16__>& n,
+  const std::vector<T17__, Alloc17__>& o,
+  const std::vector<T18__, Alloc18__>& p,
+  const std::vector<T19__, Alloc19__>& q, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T4__, T5__, T6__, T7__, T8__, T9__, T10__, T11__, T12__, T13__, T14__, T15__, T16__, T17__, T18__, T19__>;
   int current_statement__ = 0; 
   const auto& c = to_ref(c_arg__);
   const auto& d = to_ref(d_arg__);
@@ -28486,30 +28318,30 @@ s(const std::vector<T0__>& y_slice, const int& start, const int& end,
 }
 
 struct s_functor__ {
-template <typename T0__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T9__, typename T10__, typename T11__, typename T12__,
-typename T14__, typename T15__, typename T16__, typename T17__,
-typename T19__>
-stan::promote_args_t<T0__, T4__, stan::value_type_t<T5__>,
-stan::value_type_t<T6__>,
-stan::value_type_t<T7__>, stan::promote_args_t<T9__, T10__, T11__, T12__,
-T14__, stan::promote_args_t<T15__, T16__, T17__,
-T19__>>>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T4__, typename T5__,
+typename T6__, typename T7__, typename T8__, typename Alloc8__,
+typename T9__, typename Alloc9__, typename T10__, typename Alloc10__,
+typename T11__, typename Alloc11__, typename T12__, typename Alloc12__,
+typename T13__, typename Alloc13__, typename T14__, typename Alloc14__,
+typename T15__, typename Alloc15__, typename T16__, typename Alloc16__,
+typename T17__, typename Alloc17__, typename T18__, typename Alloc18__,
+typename T19__, typename Alloc19__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, const int& a, const T4__& b, const T5__& c,
-           const T6__& d, const T7__& e, const std::vector<int>& f,
-           const std::vector<T9__>& g,
-           const std::vector<Eigen::Matrix<T10__, -1, 1>>& h,
-           const std::vector<Eigen::Matrix<T11__, 1, -1>>& i,
-           const std::vector<Eigen::Matrix<T12__, -1, -1>>& j,
-           const std::vector<std::vector<int>>& k,
-           const std::vector<std::vector<T14__>>& l,
-           const std::vector<std::vector<Eigen::Matrix<T15__, -1, 1>>>& m,
-           const std::vector<std::vector<Eigen::Matrix<T16__, 1, -1>>>& n,
-           const std::vector<std::vector<Eigen::Matrix<T17__, -1, -1>>>& o,
-           const std::vector<std::vector<std::vector<int>>>& p,
-           const std::vector<std::vector<std::vector<T19__>>>& q,
-           std::ostream* pstream__)  const 
+           const T6__& d, const T7__& e,
+           const std::vector<T8__, Alloc8__>& f,
+           const std::vector<T9__, Alloc9__>& g,
+           const std::vector<T10__, Alloc10__>& h,
+           const std::vector<T11__, Alloc11__>& i,
+           const std::vector<T12__, Alloc12__>& j,
+           const std::vector<T13__, Alloc13__>& k,
+           const std::vector<T14__, Alloc14__>& l,
+           const std::vector<T15__, Alloc15__>& m,
+           const std::vector<T16__, Alloc16__>& n,
+           const std::vector<T17__, Alloc17__>& o,
+           const std::vector<T18__, Alloc18__>& p,
+           const std::vector<T19__, Alloc19__>& q, std::ostream* pstream__)  const 
 {
 return s(y_slice, start, end, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p,
          q, pstream__);
@@ -28518,36 +28350,37 @@ return s(y_slice, start, end, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p,
 
 
 struct s_rsfunctor__ {
-template <typename T0__, typename T4__, typename T5__, typename T6__,
-typename T7__, typename T9__, typename T10__, typename T11__, typename T12__,
-typename T14__, typename T15__, typename T16__, typename T17__,
-typename T19__>
-stan::promote_args_t<T0__, T4__, stan::value_type_t<T5__>,
-stan::value_type_t<T6__>,
-stan::value_type_t<T7__>, stan::promote_args_t<T9__, T10__, T11__, T12__,
-T14__, stan::promote_args_t<T15__, T16__, T17__,
-T19__>>>
-operator()(const std::vector<T0__>& y_slice, const int& start,
+template <typename T0__, typename Alloc0__, typename T4__, typename T5__,
+typename T6__, typename T7__, typename T8__, typename Alloc8__,
+typename T9__, typename Alloc9__, typename T10__, typename Alloc10__,
+typename T11__, typename Alloc11__, typename T12__, typename Alloc12__,
+typename T13__, typename Alloc13__, typename T14__, typename Alloc14__,
+typename T15__, typename Alloc15__, typename T16__, typename Alloc16__,
+typename T17__, typename Alloc17__, typename T18__, typename Alloc18__,
+typename T19__, typename Alloc19__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& y_slice, const int& start,
            const int& end, std::ostream* pstream__, const int& a,
            const T4__& b, const T5__& c, const T6__& d, const T7__& e,
-           const std::vector<int>& f, const std::vector<T9__>& g,
-           const std::vector<Eigen::Matrix<T10__, -1, 1>>& h,
-           const std::vector<Eigen::Matrix<T11__, 1, -1>>& i,
-           const std::vector<Eigen::Matrix<T12__, -1, -1>>& j,
-           const std::vector<std::vector<int>>& k,
-           const std::vector<std::vector<T14__>>& l,
-           const std::vector<std::vector<Eigen::Matrix<T15__, -1, 1>>>& m,
-           const std::vector<std::vector<Eigen::Matrix<T16__, 1, -1>>>& n,
-           const std::vector<std::vector<Eigen::Matrix<T17__, -1, -1>>>& o,
-           const std::vector<std::vector<std::vector<int>>>& p,
-           const std::vector<std::vector<std::vector<T19__>>>& q)  const 
+           const std::vector<T8__, Alloc8__>& f,
+           const std::vector<T9__, Alloc9__>& g,
+           const std::vector<T10__, Alloc10__>& h,
+           const std::vector<T11__, Alloc11__>& i,
+           const std::vector<T12__, Alloc12__>& j,
+           const std::vector<T13__, Alloc13__>& k,
+           const std::vector<T14__, Alloc14__>& l,
+           const std::vector<T15__, Alloc15__>& m,
+           const std::vector<T16__, Alloc16__>& n,
+           const std::vector<T17__, Alloc17__>& o,
+           const std::vector<T18__, Alloc18__>& p,
+           const std::vector<T19__, Alloc19__>& q)  const 
 {
 return s(y_slice, start + 1, end + 1, a, b, c, d, e, f, g, h, i, j, k, l, m,
          n, o, p, q, pstream__);
 }
 };
 
-double
+inline auto
 r(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -28934,7 +28767,7 @@ r(std::ostream* pstream__) {
 }
 
 struct r_functor__ {
-double
+inline auto
 operator()(std::ostream* pstream__)  const 
 {
 return r(pstream__);
@@ -30968,9 +30801,9 @@ static constexpr std::array<const char*, 13> locations_array__ =
 
 
 template <bool propto__>
-double
+inline auto
 foo0_lpmf(const int& y, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -30985,7 +30818,7 @@ foo0_lpmf(const int& y, std::ostream* pstream__) {
 
 struct foo0_lpmf_functor__ {
 template <bool propto__>
-double
+inline auto
 operator()(const int& y, std::ostream* pstream__)  const 
 {
 return foo0_lpmf<propto__>(y, pstream__);
@@ -30993,9 +30826,9 @@ return foo0_lpmf<propto__>(y, pstream__);
 };
 
 template <bool propto__>
-double
+inline auto
 foo1_lpmf(const int& y, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -31010,7 +30843,7 @@ foo1_lpmf(const int& y, std::ostream* pstream__) {
 
 struct foo1_lpmf_functor__ {
 template <bool propto__>
-double
+inline auto
 operator()(const int& y, std::ostream* pstream__)  const 
 {
 return foo1_lpmf<propto__>(y, pstream__);
@@ -31018,10 +30851,10 @@ return foo1_lpmf<propto__>(y, pstream__);
 };
 
 template <bool propto__, typename T_lp__, typename T_lp_accum__>
-double
+inline auto
 foo4_lp(const int& y, T_lp__& lp__, T_lp_accum__& lp_accum__,
         std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -31036,7 +30869,7 @@ foo4_lp(const int& y, T_lp__& lp__, T_lp_accum__& lp_accum__,
 
 struct foo4_lp_functor__ {
 template <bool propto__, typename T_lp__, typename T_lp_accum__>
-double
+inline auto
 operator()(const int& y, T_lp__& lp__, T_lp_accum__& lp_accum__,
            std::ostream* pstream__)  const 
 {
@@ -31045,9 +30878,9 @@ return foo4_lp<propto__>(y, lp__, lp_accum__, pstream__);
 };
 
 template <bool propto__, typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 foo2_lpdf(const T0__& y, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -31062,7 +30895,7 @@ foo2_lpdf(const T0__& y, std::ostream* pstream__) {
 
 struct foo2_lpdf_functor__ {
 template <bool propto__, typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& y, std::ostream* pstream__)  const 
 {
 return foo2_lpdf<propto__>(y, pstream__);
@@ -31070,9 +30903,9 @@ return foo2_lpdf<propto__>(y, pstream__);
 };
 
 template <bool propto__, typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 foo3_lpdf(const T0__& y, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -31087,7 +30920,7 @@ foo3_lpdf(const T0__& y, std::ostream* pstream__) {
 
 struct foo3_lpdf_functor__ {
 template <bool propto__, typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& y, std::ostream* pstream__)  const 
 {
 return foo3_lpdf<propto__>(y, pstream__);
@@ -31096,10 +30929,10 @@ return foo3_lpdf<propto__>(y, pstream__);
 
 template <bool propto__, typename T0__, typename T_lp__,
 typename T_lp_accum__>
-stan::promote_args_t<T0__>
+inline auto
 foo5_lp(const T0__& y, T_lp__& lp__, T_lp_accum__& lp_accum__,
         std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -31115,7 +30948,7 @@ foo5_lp(const T0__& y, T_lp__& lp__, T_lp_accum__& lp_accum__,
 struct foo5_lp_functor__ {
 template <bool propto__, typename T0__, typename T_lp__,
 typename T_lp_accum__>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& y, T_lp__& lp__, T_lp_accum__& lp_accum__,
            std::ostream* pstream__)  const 
 {
@@ -35056,9 +34889,9 @@ static constexpr std::array<const char*, 5> locations_array__ =
 
 
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 normal(const T0__& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -35075,7 +34908,7 @@ normal(const T0__& a, std::ostream* pstream__) {
 
 struct normal_functor__ {
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& a, std::ostream* pstream__)  const 
 {
 return normal(a, pstream__);
@@ -35424,10 +35257,9 @@ static constexpr std::array<const char*, 5> locations_array__ =
 
 
 template <typename T0__, typename T1__>
-stan::promote_args_t<T0__,
-T1__>
+inline auto
 lb_constrain(const T0__& x, const T1__& y, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T1__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -35444,8 +35276,7 @@ lb_constrain(const T0__& x, const T1__& y, std::ostream* pstream__) {
 
 struct lb_constrain_functor__ {
 template <typename T0__, typename T1__>
-stan::promote_args_t<T0__,
-T1__>
+inline auto
 operator()(const T0__& x, const T1__& y, std::ostream* pstream__)  const 
 {
 return lb_constrain(x, y, pstream__);
diff --git a/test/integration/good/code-gen/expressions/cpp.expected b/test/integration/good/code-gen/expressions/cpp.expected
index 211a3e9204..80db81d786 100644
--- a/test/integration/good/code-gen/expressions/cpp.expected
+++ b/test/integration/good/code-gen/expressions/cpp.expected
@@ -34,19 +34,13 @@ static constexpr std::array<const char*, 13> locations_array__ =
  " (in 'simple_function.stan', line 11, column 37 to line 13, column 3)"};
 
 
-template <typename T0__, typename T2__, typename T3__, typename T4__,
-typename T5__>
-stan::promote_args_t<T0__, T2__, stan::value_type_t<T3__>,
-stan::value_type_t<T4__>,
-stan::value_type_t<T5__>>
-foo1(const T0__& a, const int& b, const std::vector<T2__>& c,
+template <typename T0__, typename T2__, typename Alloc2__, typename T3__,
+typename T4__, typename T5__>
+inline auto
+foo1(const T0__& a, const int& b, const std::vector<T2__, Alloc2__>& c,
      const T3__& d_arg__, const T4__& e_arg__, const T5__& f_arg__,
      std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__,
-          T2__,
-          stan::value_type_t<T3__>,
-          stan::value_type_t<T4__>,
-          stan::value_type_t<T5__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T2__, T3__, T4__, T5__>;
   int current_statement__ = 0; 
   const auto& d = to_ref(d_arg__);
   const auto& e = to_ref(e_arg__);
@@ -65,12 +59,10 @@ foo1(const T0__& a, const int& b, const std::vector<T2__>& c,
 }
 
 struct foo1_functor__ {
-template <typename T0__, typename T2__, typename T3__, typename T4__,
-typename T5__>
-stan::promote_args_t<T0__, T2__, stan::value_type_t<T3__>,
-stan::value_type_t<T4__>,
-stan::value_type_t<T5__>>
-operator()(const T0__& a, const int& b, const std::vector<T2__>& c,
+template <typename T0__, typename T2__, typename Alloc2__, typename T3__,
+typename T4__, typename T5__>
+inline auto
+operator()(const T0__& a, const int& b, const std::vector<T2__, Alloc2__>& c,
            const T3__& d, const T4__& e, const T5__& f,
            std::ostream* pstream__)  const 
 {
@@ -78,15 +70,12 @@ return foo1(a, b, c, d, e, f, pstream__);
 }
 };
 
-template <typename T0__, typename T1__, typename T2__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>, T1__,
-T2__>, -1, 1>
-foo2(const T0__& a_arg__, const std::vector<Eigen::Matrix<T1__, -1, -1>>& b,
-     const std::vector<Eigen::Matrix<T2__, 1, -1>>& c,
-     std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>,
-          T1__,
-          T2__>;
+template <typename T0__, typename T1__, typename Alloc1__, typename T2__,
+typename Alloc2__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__>, -1, 1>
+foo2(const T0__& a_arg__, const std::vector<T1__, Alloc1__>& b,
+     const std::vector<T2__, Alloc2__>& c, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__>;
   int current_statement__ = 0; 
   const auto& a = to_ref(a_arg__);
   static constexpr bool propto__ = true;
@@ -103,23 +92,20 @@ foo2(const T0__& a_arg__, const std::vector<Eigen::Matrix<T1__, -1, -1>>& b,
 }
 
 struct foo2_functor__ {
-template <typename T0__, typename T1__, typename T2__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>, T1__,
-T2__>, -1, 1>
-operator()(const T0__& a, const std::vector<Eigen::Matrix<T1__, -1, -1>>& b,
-           const std::vector<Eigen::Matrix<T2__, 1, -1>>& c,
-           std::ostream* pstream__)  const 
+template <typename T0__, typename T1__, typename Alloc1__, typename T2__,
+typename Alloc2__>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__>, -1, 1>
+operator()(const T0__& a, const std::vector<T1__, Alloc1__>& b,
+           const std::vector<T2__, Alloc2__>& c, std::ostream* pstream__)  const 
 {
 return foo2(a, b, c, pstream__);
 }
 };
 
 template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>,
-stan::value_type_t<T1__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__>, -1, -1>
 foo3(const T0__& a_arg__, const T1__& b_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>,
-          stan::value_type_t<T1__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__>;
   int current_statement__ = 0; 
   const auto& a = to_ref(a_arg__);
   const auto& b = to_ref(b_arg__);
@@ -138,8 +124,7 @@ foo3(const T0__& a_arg__, const T1__& b_arg__, std::ostream* pstream__) {
 
 struct foo3_functor__ {
 template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>,
-stan::value_type_t<T1__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__>, -1, -1>
 operator()(const T0__& a, const T1__& b, std::ostream* pstream__)  const 
 {
 return foo3(a, b, pstream__);
@@ -147,11 +132,9 @@ return foo3(a, b, pstream__);
 };
 
 template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>,
-stan::value_type_t<T1__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__>, -1, -1>
 add_udf(const T0__& a_arg__, const T1__& b_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>,
-          stan::value_type_t<T1__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__>;
   int current_statement__ = 0; 
   const auto& a = to_ref(a_arg__);
   const auto& b = to_ref(b_arg__);
@@ -170,8 +153,7 @@ add_udf(const T0__& a_arg__, const T1__& b_arg__, std::ostream* pstream__) {
 
 struct add_udf_functor__ {
 template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>,
-stan::value_type_t<T1__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__>, -1, -1>
 operator()(const T0__& a, const T1__& b, std::ostream* pstream__)  const 
 {
 return add_udf(a, b, pstream__);
diff --git a/test/integration/good/code-gen/ode/cpp.expected b/test/integration/good/code-gen/ode/cpp.expected
index fb50216bc9..866829c945 100644
--- a/test/integration/good/code-gen/ode/cpp.expected
+++ b/test/integration/good/code-gen/ode/cpp.expected
@@ -58,11 +58,9 @@ static constexpr std::array<const char*, 36> locations_array__ =
 
 
 template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<T0__,
-stan::value_type_t<T1__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__>, -1, 1>
 f_0_arg(const T0__& t, const T1__& z_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__,
-          stan::value_type_t<T1__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__>;
   int current_statement__ = 0; 
   const auto& z = to_ref(z_arg__);
   static constexpr bool propto__ = true;
@@ -80,8 +78,7 @@ f_0_arg(const T0__& t, const T1__& z_arg__, std::ostream* pstream__) {
 
 struct f_0_arg_functor__ {
 template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<T0__,
-stan::value_type_t<T1__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__>, -1, 1>
 operator()(const T0__& t, const T1__& z, std::ostream* pstream__)  const 
 {
 return f_0_arg(t, z, pstream__);
@@ -91,8 +88,7 @@ return f_0_arg(t, z, pstream__);
 
 struct f_0_arg_odefunctor__ {
 template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<T0__,
-stan::value_type_t<T1__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__>, -1, 1>
 operator()(const T0__& t, const T1__& z, std::ostream* pstream__)  const 
 {
 return f_0_arg(t, z, pstream__);
@@ -100,13 +96,10 @@ return f_0_arg(t, z, pstream__);
 };
 
 template <typename T0__, typename T1__, typename T2__>
-Eigen::Matrix<stan::promote_args_t<T0__, stan::value_type_t<T1__>,
-T2__>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__>, -1, 1>
 f_1_arg(const T0__& t, const T1__& z_arg__, const T2__& a,
         std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__,
-          stan::value_type_t<T1__>,
-          T2__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__>;
   int current_statement__ = 0; 
   const auto& z = to_ref(z_arg__);
   static constexpr bool propto__ = true;
@@ -124,8 +117,7 @@ f_1_arg(const T0__& t, const T1__& z_arg__, const T2__& a,
 
 struct f_1_arg_functor__ {
 template <typename T0__, typename T1__, typename T2__>
-Eigen::Matrix<stan::promote_args_t<T0__, stan::value_type_t<T1__>,
-T2__>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__>, -1, 1>
 operator()(const T0__& t, const T1__& z, const T2__& a,
            std::ostream* pstream__)  const 
 {
@@ -136,8 +128,7 @@ return f_1_arg(t, z, a, pstream__);
 
 struct f_1_arg_odefunctor__ {
 template <typename T0__, typename T1__, typename T2__>
-Eigen::Matrix<stan::promote_args_t<T0__, stan::value_type_t<T1__>,
-T2__>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__>, -1, 1>
 operator()(const T0__& t, const T1__& z, std::ostream* pstream__,
            const T2__& a)  const 
 {
@@ -146,13 +137,10 @@ return f_1_arg(t, z, a, pstream__);
 };
 
 template <typename T0__, typename T1__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<T0__, stan::value_type_t<T1__>,
-T3__>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T3__>, -1, 1>
 f_2_arg(const T0__& t, const T1__& z_arg__, const int& b, const T3__& a,
         std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__,
-          stan::value_type_t<T1__>,
-          T3__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T3__>;
   int current_statement__ = 0; 
   const auto& z = to_ref(z_arg__);
   static constexpr bool propto__ = true;
@@ -170,8 +158,7 @@ f_2_arg(const T0__& t, const T1__& z_arg__, const int& b, const T3__& a,
 
 struct f_2_arg_functor__ {
 template <typename T0__, typename T1__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<T0__, stan::value_type_t<T1__>,
-T3__>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T3__>, -1, 1>
 operator()(const T0__& t, const T1__& z, const int& b, const T3__& a,
            std::ostream* pstream__)  const 
 {
@@ -182,8 +169,7 @@ return f_2_arg(t, z, b, a, pstream__);
 
 struct f_2_arg_odefunctor__ {
 template <typename T0__, typename T1__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<T0__, stan::value_type_t<T1__>,
-T3__>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T3__>, -1, 1>
 operator()(const T0__& t, const T1__& z, std::ostream* pstream__,
            const int& b, const T3__& a)  const 
 {
diff --git a/test/integration/good/code-gen/standalone_functions/cpp.expected b/test/integration/good/code-gen/standalone_functions/cpp.expected
index 0df0621a8f..ad7a080be9 100644
--- a/test/integration/good/code-gen/standalone_functions/cpp.expected
+++ b/test/integration/good/code-gen/standalone_functions/cpp.expected
@@ -43,9 +43,9 @@ static constexpr std::array<const char*, 21> locations_array__ =
 
 
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 my_log1p_exp(const T0__& x, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -62,17 +62,17 @@ my_log1p_exp(const T0__& x, std::ostream* pstream__) {
 
 struct my_log1p_exp_functor__ {
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& x, std::ostream* pstream__)  const 
 {
 return my_log1p_exp(x, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-array_fun(const std::vector<T0__>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+array_fun(const std::vector<T0__, Alloc0__>& a, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -88,17 +88,18 @@ array_fun(const std::vector<T0__>& a, std::ostream* pstream__) {
 }
 
 struct array_fun_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<T0__>& a, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& a, std::ostream* pstream__)  const 
 {
 return array_fun(a, pstream__);
 }
 };
 
-double
-int_array_fun(const std::vector<int>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline auto
+int_array_fun(const std::vector<T0__, Alloc0__>& a, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -114,17 +115,18 @@ int_array_fun(const std::vector<int>& a, std::ostream* pstream__) {
 }
 
 struct int_array_fun_functor__ {
-double
-operator()(const std::vector<int>& a, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& a, std::ostream* pstream__)  const 
 {
 return int_array_fun(a, pstream__);
 }
 };
 
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, 1>
 my_vector_mul_by_5(const T0__& x_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   const auto& x = to_ref(x_arg__);
   static constexpr bool propto__ = true;
@@ -150,16 +152,16 @@ my_vector_mul_by_5(const T0__& x_arg__, std::ostream* pstream__) {
 
 struct my_vector_mul_by_5_functor__ {
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, 1>
 operator()(const T0__& x, std::ostream* pstream__)  const 
 {
 return my_vector_mul_by_5(x, pstream__);
 }
 };
 
-int
+inline int
 int_only_multiplication(const int& a, const int& b, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -175,7 +177,7 @@ int_only_multiplication(const int& a, const int& b, std::ostream* pstream__) {
 }
 
 struct int_only_multiplication_functor__ {
-int
+inline int
 operator()(const int& a, const int& b, std::ostream* pstream__)  const 
 {
 return int_only_multiplication(a, b, pstream__);
@@ -183,9 +185,9 @@ return int_only_multiplication(a, b, pstream__);
 };
 
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 test_lgamma(const T0__& x, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -202,7 +204,7 @@ test_lgamma(const T0__& x, std::ostream* pstream__) {
 
 struct test_lgamma_functor__ {
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& x, std::ostream* pstream__)  const 
 {
 return test_lgamma(x, pstream__);
@@ -211,10 +213,10 @@ return test_lgamma(x, pstream__);
 
 template <bool propto__, typename T0__, typename T_lp__,
 typename T_lp_accum__>
-void
+inline void
 test_lp(const T0__& a, T_lp__& lp__, T_lp_accum__& lp_accum__,
         std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -230,7 +232,7 @@ test_lp(const T0__& a, T_lp__& lp__, T_lp_accum__& lp_accum__,
 struct test_lp_functor__ {
 template <bool propto__, typename T0__, typename T_lp__,
 typename T_lp_accum__>
-void
+inline void
 operator()(const T0__& a, T_lp__& lp__, T_lp_accum__& lp_accum__,
            std::ostream* pstream__)  const 
 {
@@ -239,9 +241,9 @@ return test_lp<propto__>(a, lp__, lp_accum__, pstream__);
 };
 
 template <typename T0__, typename RNG>
-stan::promote_args_t<T0__>
+inline auto
 test_rng(const T0__& a, RNG& base_rng__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -258,7 +260,7 @@ test_rng(const T0__& a, RNG& base_rng__, std::ostream* pstream__) {
 
 struct test_rng_functor__ {
 template <typename T0__, typename RNG>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& a, RNG& base_rng__, std::ostream* pstream__)  const 
 {
 return test_rng(a, base_rng__, pstream__);
@@ -266,10 +268,9 @@ return test_rng(a, base_rng__, pstream__);
 };
 
 template <bool propto__, typename T0__, typename T1__>
-stan::promote_args_t<T0__,
-T1__>
+inline auto
 test_lpdf(const T0__& a, const T1__& b, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T1__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -284,8 +285,7 @@ test_lpdf(const T0__& a, const T1__& b, std::ostream* pstream__) {
 
 struct test_lpdf_functor__ {
 template <bool propto__, typename T0__, typename T1__>
-stan::promote_args_t<T0__,
-T1__>
+inline auto
 operator()(const T0__& a, const T1__& b, std::ostream* pstream__)  const 
 {
 return test_lpdf<propto__>(a, b, pstream__);
@@ -411,9 +411,9 @@ static constexpr std::array<const char*, 21> locations_array__ =
 
 
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 my_log1p_exp(const T0__& x, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -430,17 +430,17 @@ my_log1p_exp(const T0__& x, std::ostream* pstream__) {
 
 struct my_log1p_exp_functor__ {
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& x, std::ostream* pstream__)  const 
 {
 return my_log1p_exp(x, pstream__);
 }
 };
 
-template <typename T0__>
-stan::promote_args_t<T0__>
-array_fun(const std::vector<T0__>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+template <typename T0__, typename Alloc0__>
+inline auto
+array_fun(const std::vector<T0__, Alloc0__>& a, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -456,17 +456,18 @@ array_fun(const std::vector<T0__>& a, std::ostream* pstream__) {
 }
 
 struct array_fun_functor__ {
-template <typename T0__>
-stan::promote_args_t<T0__>
-operator()(const std::vector<T0__>& a, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& a, std::ostream* pstream__)  const 
 {
 return array_fun(a, pstream__);
 }
 };
 
-double
-int_array_fun(const std::vector<int>& a, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline auto
+int_array_fun(const std::vector<T0__, Alloc0__>& a, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -482,17 +483,18 @@ int_array_fun(const std::vector<int>& a, std::ostream* pstream__) {
 }
 
 struct int_array_fun_functor__ {
-double
-operator()(const std::vector<int>& a, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline auto
+operator()(const std::vector<T0__, Alloc0__>& a, std::ostream* pstream__)  const 
 {
 return int_array_fun(a, pstream__);
 }
 };
 
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, 1>
 my_vector_mul_by_5(const T0__& x_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   const auto& x = to_ref(x_arg__);
   static constexpr bool propto__ = true;
@@ -518,16 +520,16 @@ my_vector_mul_by_5(const T0__& x_arg__, std::ostream* pstream__) {
 
 struct my_vector_mul_by_5_functor__ {
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, 1>
 operator()(const T0__& x, std::ostream* pstream__)  const 
 {
 return my_vector_mul_by_5(x, pstream__);
 }
 };
 
-int
+inline int
 int_only_multiplication(const int& a, const int& b, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -543,7 +545,7 @@ int_only_multiplication(const int& a, const int& b, std::ostream* pstream__) {
 }
 
 struct int_only_multiplication_functor__ {
-int
+inline int
 operator()(const int& a, const int& b, std::ostream* pstream__)  const 
 {
 return int_only_multiplication(a, b, pstream__);
@@ -551,9 +553,9 @@ return int_only_multiplication(a, b, pstream__);
 };
 
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 test_lgamma(const T0__& x, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -570,7 +572,7 @@ test_lgamma(const T0__& x, std::ostream* pstream__) {
 
 struct test_lgamma_functor__ {
 template <typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& x, std::ostream* pstream__)  const 
 {
 return test_lgamma(x, pstream__);
@@ -579,10 +581,10 @@ return test_lgamma(x, pstream__);
 
 template <bool propto__, typename T0__, typename T_lp__,
 typename T_lp_accum__>
-void
+inline void
 test_lp(const T0__& a, T_lp__& lp__, T_lp_accum__& lp_accum__,
         std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -598,7 +600,7 @@ test_lp(const T0__& a, T_lp__& lp__, T_lp_accum__& lp_accum__,
 struct test_lp_functor__ {
 template <bool propto__, typename T0__, typename T_lp__,
 typename T_lp_accum__>
-void
+inline void
 operator()(const T0__& a, T_lp__& lp__, T_lp_accum__& lp_accum__,
            std::ostream* pstream__)  const 
 {
@@ -607,9 +609,9 @@ return test_lp<propto__>(a, lp__, lp_accum__, pstream__);
 };
 
 template <typename T0__, typename RNG>
-stan::promote_args_t<T0__>
+inline auto
 test_rng(const T0__& a, RNG& base_rng__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -626,7 +628,7 @@ test_rng(const T0__& a, RNG& base_rng__, std::ostream* pstream__) {
 
 struct test_rng_functor__ {
 template <typename T0__, typename RNG>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& a, RNG& base_rng__, std::ostream* pstream__)  const 
 {
 return test_rng(a, base_rng__, pstream__);
@@ -634,10 +636,9 @@ return test_rng(a, base_rng__, pstream__);
 };
 
 template <bool propto__, typename T0__, typename T1__>
-stan::promote_args_t<T0__,
-T1__>
+inline auto
 test_lpdf(const T0__& a, const T1__& b, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T1__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -652,8 +653,7 @@ test_lpdf(const T0__& a, const T1__& b, std::ostream* pstream__) {
 
 struct test_lpdf_functor__ {
 template <bool propto__, typename T0__, typename T1__>
-stan::promote_args_t<T0__,
-T1__>
+inline auto
 operator()(const T0__& a, const T1__& b, std::ostream* pstream__)  const 
 {
 return test_lpdf<propto__>(a, b, pstream__);
@@ -769,9 +769,9 @@ static constexpr std::array<const char*, 11> locations_array__ =
 
 
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, 1>
 integrand(const T0__& x_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   const auto& x = to_ref(x_arg__);
   static constexpr bool propto__ = true;
@@ -789,20 +789,22 @@ integrand(const T0__& x_arg__, std::ostream* pstream__) {
 
 struct integrand_functor__ {
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, 1>
 operator()(const T0__& x, std::ostream* pstream__)  const 
 {
 return integrand(x, pstream__);
 }
 };
 
-template <typename T0__, typename T1__, typename T2__, typename T3__>
-std::vector<stan::promote_args_t<T0__, T1__, T2__,
-T3__>>
-integrand_ode(const T0__& r, const std::vector<T1__>& f,
-              const std::vector<T2__>& theta, const std::vector<T3__>& x_r,
-              const std::vector<int>& x_i, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T1__, T2__, T3__>;
+template <typename T0__, typename T1__, typename Alloc1__, typename T2__,
+typename Alloc2__, typename T3__, typename Alloc3__, typename T4__,
+typename Alloc4__>
+inline std::vector<stan::return_type_t<T0__, T1__, T2__, T3__, T4__>>
+integrand_ode(const T0__& r, const std::vector<T1__, Alloc1__>& f,
+              const std::vector<T2__, Alloc2__>& theta,
+              const std::vector<T3__, Alloc3__>& x_r,
+              const std::vector<T4__, Alloc4__>& x_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__, T4__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -829,18 +831,20 @@ integrand_ode(const T0__& r, const std::vector<T1__>& f,
 }
 
 struct integrand_ode_functor__ {
-template <typename T0__, typename T1__, typename T2__, typename T3__>
-std::vector<stan::promote_args_t<T0__, T1__, T2__,
-T3__>>
-operator()(const T0__& r, const std::vector<T1__>& f,
-           const std::vector<T2__>& theta, const std::vector<T3__>& x_r,
-           const std::vector<int>& x_i, std::ostream* pstream__)  const 
+template <typename T0__, typename T1__, typename Alloc1__, typename T2__,
+typename Alloc2__, typename T3__, typename Alloc3__, typename T4__,
+typename Alloc4__>
+inline std::vector<stan::return_type_t<T0__, T1__, T2__, T3__, T4__>>
+operator()(const T0__& r, const std::vector<T1__, Alloc1__>& f,
+           const std::vector<T2__, Alloc2__>& theta,
+           const std::vector<T3__, Alloc3__>& x_r,
+           const std::vector<T4__, Alloc4__>& x_i, std::ostream* pstream__)  const 
 {
 return integrand_ode(r, f, theta, x_r, x_i, pstream__);
 }
 };
 
-double
+inline auto
 ode_integrate(std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -866,7 +870,7 @@ ode_integrate(std::ostream* pstream__) {
 }
 
 struct ode_integrate_functor__ {
-double
+inline auto
 operator()(std::ostream* pstream__)  const 
 {
 return ode_integrate(pstream__);
diff --git a/test/integration/good/compiler-optimizations/cpp.expected b/test/integration/good/compiler-optimizations/cpp.expected
index a3e506093e..58f1f673c7 100644
--- a/test/integration/good/compiler-optimizations/cpp.expected
+++ b/test/integration/good/compiler-optimizations/cpp.expected
@@ -56,13 +56,15 @@ static constexpr std::array<const char*, 35> locations_array__ =
  " (in 'ad-level-failing.stan', line 11, column 61 to line 20, column 3)"};
 
 
-template <typename T0__, typename T1__, typename T2__, typename T3__>
-std::vector<stan::promote_args_t<T0__, T1__, T2__,
-T3__>>
-simple_SIR(const T0__& t, const std::vector<T1__>& y,
-           const std::vector<T2__>& theta, const std::vector<T3__>& x_r,
-           const std::vector<int>& x_i, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T1__, T2__, T3__>;
+template <typename T0__, typename T1__, typename Alloc1__, typename T2__,
+typename Alloc2__, typename T3__, typename Alloc3__, typename T4__,
+typename Alloc4__>
+inline std::vector<stan::return_type_t<T0__, T1__, T2__, T3__, T4__>>
+simple_SIR(const T0__& t, const std::vector<T1__, Alloc1__>& y,
+           const std::vector<T2__, Alloc2__>& theta,
+           const std::vector<T3__, Alloc3__>& x_r,
+           const std::vector<T4__, Alloc4__>& x_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__, T4__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -113,12 +115,14 @@ simple_SIR(const T0__& t, const std::vector<T1__>& y,
 }
 
 struct simple_SIR_functor__ {
-template <typename T0__, typename T1__, typename T2__, typename T3__>
-std::vector<stan::promote_args_t<T0__, T1__, T2__,
-T3__>>
-operator()(const T0__& t, const std::vector<T1__>& y,
-           const std::vector<T2__>& theta, const std::vector<T3__>& x_r,
-           const std::vector<int>& x_i, std::ostream* pstream__)  const 
+template <typename T0__, typename T1__, typename Alloc1__, typename T2__,
+typename Alloc2__, typename T3__, typename Alloc3__, typename T4__,
+typename Alloc4__>
+inline std::vector<stan::return_type_t<T0__, T1__, T2__, T3__, T4__>>
+operator()(const T0__& t, const std::vector<T1__, Alloc1__>& y,
+           const std::vector<T2__, Alloc2__>& theta,
+           const std::vector<T3__, Alloc3__>& x_r,
+           const std::vector<T4__, Alloc4__>& x_i, std::ostream* pstream__)  const 
 {
 return simple_SIR(t, y, theta, x_r, x_i, pstream__);
 }
@@ -905,9 +909,10 @@ static constexpr std::array<const char*, 68> locations_array__ =
  " (in 'copy_fail.stan', line 45, column 4 to column 15)"};
 
 
-int
-first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline int
+first_capture(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -944,16 +949,18 @@ first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
 }
 
 struct first_capture_functor__ {
-int
-operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline int
+operator()(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__)  const 
 {
 return first_capture(y_i, pstream__);
 }
 };
 
-int
-last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline int
+last_capture(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -996,20 +1003,19 @@ last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
 }
 
 struct last_capture_functor__ {
-int
-operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline int
+operator()(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__)  const 
 {
 return last_capture(y_i, pstream__);
 }
 };
 
 template <typename T2__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T2__>,
-stan::value_type_t<T3__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T2__, T3__>, -1, -1>
 prob_uncaptured(const int& nind, const int& n_occasions, const T2__& p_arg__,
                 const T3__& phi_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T2__>,
-          stan::value_type_t<T3__>>;
+  using local_scalar_t__ = stan::return_type_t<T2__, T3__>;
   int current_statement__ = 0; 
   const auto& p = to_ref(p_arg__);
   const auto& phi = to_ref(phi_arg__);
@@ -1127,8 +1133,7 @@ prob_uncaptured(const int& nind, const int& n_occasions, const T2__& p_arg__,
 
 struct prob_uncaptured_functor__ {
 template <typename T2__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T2__>,
-stan::value_type_t<T3__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T2__, T3__>, -1, -1>
 operator()(const int& nind, const int& n_occasions, const T2__& p,
            const T3__& phi, std::ostream* pstream__)  const 
 {
@@ -7981,9 +7986,10 @@ static constexpr std::array<const char*, 70> locations_array__ =
  " (in 'expr-prop-fail5.stan', line 47, column 4 to column 15)"};
 
 
-int
-first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline int
+first_capture(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -8020,16 +8026,18 @@ first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
 }
 
 struct first_capture_functor__ {
-int
-operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline int
+operator()(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__)  const 
 {
 return first_capture(y_i, pstream__);
 }
 };
 
-int
-last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline int
+last_capture(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -8072,20 +8080,19 @@ last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
 }
 
 struct last_capture_functor__ {
-int
-operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline int
+operator()(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__)  const 
 {
 return last_capture(y_i, pstream__);
 }
 };
 
 template <typename T2__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T2__>,
-stan::value_type_t<T3__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T2__, T3__>, -1, -1>
 prob_uncaptured(const int& nind, const int& n_occasions, const T2__& p_arg__,
                 const T3__& phi_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T2__>,
-          stan::value_type_t<T3__>>;
+  using local_scalar_t__ = stan::return_type_t<T2__, T3__>;
   int current_statement__ = 0; 
   const auto& p = to_ref(p_arg__);
   const auto& phi = to_ref(phi_arg__);
@@ -8211,8 +8218,7 @@ prob_uncaptured(const int& nind, const int& n_occasions, const T2__& p_arg__,
 
 struct prob_uncaptured_functor__ {
 template <typename T2__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T2__>,
-stan::value_type_t<T3__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T2__, T3__>, -1, -1>
 operator()(const int& nind, const int& n_occasions, const T2__& p,
            const T3__& phi, std::ostream* pstream__)  const 
 {
@@ -10111,9 +10117,10 @@ static constexpr std::array<const char*, 146> locations_array__ =
  " (in 'expr-prop-fail6.stan', line 81, column 74 to line 143, column 3)"};
 
 
-int
-first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline int
+first_capture(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -10150,16 +10157,18 @@ first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
 }
 
 struct first_capture_functor__ {
-int
-operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline int
+operator()(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__)  const 
 {
 return first_capture(y_i, pstream__);
 }
 };
 
-int
-last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline int
+last_capture(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -10202,20 +10211,19 @@ last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
 }
 
 struct last_capture_functor__ {
-int
-operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline int
+operator()(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__)  const 
 {
 return last_capture(y_i, pstream__);
 }
 };
 
 template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>,
-stan::value_type_t<T1__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__>, -1, -1>
 prob_uncaptured(const T0__& p_arg__, const T1__& phi_arg__,
                 std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>,
-          stan::value_type_t<T1__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__>;
   int current_statement__ = 0; 
   const auto& p = to_ref(p_arg__);
   const auto& phi = to_ref(phi_arg__);
@@ -10334,27 +10342,25 @@ prob_uncaptured(const T0__& p_arg__, const T1__& phi_arg__,
 
 struct prob_uncaptured_functor__ {
 template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>,
-stan::value_type_t<T1__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__>, -1, -1>
 operator()(const T0__& p, const T1__& phi, std::ostream* pstream__)  const 
 {
 return prob_uncaptured(p, phi, pstream__);
 }
 };
 
-template <bool propto__, typename T3__, typename T4__, typename T5__,
-typename T6__, typename T7__, typename T_lp__, typename T_lp_accum__>
-void
-js_super_lp(const std::vector<std::vector<int>>& y,
-            const std::vector<int>& first, const std::vector<int>& last,
-            const T3__& p_arg__, const T4__& phi_arg__, const T5__& psi,
-            const T6__& nu_arg__, const T7__& chi_arg__, T_lp__& lp__,
-            T_lp_accum__& lp_accum__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T3__>,
-          stan::value_type_t<T4__>,
-          T5__,
-          stan::value_type_t<T6__>,
-          stan::value_type_t<T7__>>;
+template <bool propto__, typename T0__, typename Alloc0__, typename T1__,
+typename Alloc1__, typename T2__, typename Alloc2__, typename T3__,
+typename T4__, typename T5__, typename T6__, typename T7__, typename T_lp__,
+typename T_lp_accum__>
+inline void
+js_super_lp(const std::vector<T0__, Alloc0__>& y,
+            const std::vector<T1__, Alloc1__>& first,
+            const std::vector<T2__, Alloc2__>& last, const T3__& p_arg__,
+            const T4__& phi_arg__, const T5__& psi, const T6__& nu_arg__,
+            const T7__& chi_arg__, T_lp__& lp__, T_lp_accum__& lp_accum__,
+            std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__, T4__, T5__, T6__, T7__>;
   int current_statement__ = 0; 
   const auto& p = to_ref(p_arg__);
   const auto& phi = to_ref(phi_arg__);
@@ -10791,14 +10797,16 @@ js_super_lp(const std::vector<std::vector<int>>& y,
 }
 
 struct js_super_lp_functor__ {
-template <bool propto__, typename T3__, typename T4__, typename T5__,
-typename T6__, typename T7__, typename T_lp__, typename T_lp_accum__>
-void
-operator()(const std::vector<std::vector<int>>& y,
-           const std::vector<int>& first, const std::vector<int>& last,
-           const T3__& p, const T4__& phi, const T5__& psi, const T6__& nu,
-           const T7__& chi, T_lp__& lp__, T_lp_accum__& lp_accum__,
-           std::ostream* pstream__)  const 
+template <bool propto__, typename T0__, typename Alloc0__, typename T1__,
+typename Alloc1__, typename T2__, typename Alloc2__, typename T3__,
+typename T4__, typename T5__, typename T6__, typename T7__, typename T_lp__,
+typename T_lp_accum__>
+inline void
+operator()(const std::vector<T0__, Alloc0__>& y,
+           const std::vector<T1__, Alloc1__>& first,
+           const std::vector<T2__, Alloc2__>& last, const T3__& p,
+           const T4__& phi, const T5__& psi, const T6__& nu, const T7__& chi,
+           T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__)  const 
 {
 return js_super_lp<propto__>(y, first, last, p, phi, psi, nu, chi, lp__,
          lp_accum__, pstream__);
@@ -15285,9 +15293,10 @@ static constexpr std::array<const char*, 68> locations_array__ =
  " (in 'fails-test.stan', line 45, column 4 to column 15)"};
 
 
-int
-first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline int
+first_capture(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -15324,16 +15333,18 @@ first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
 }
 
 struct first_capture_functor__ {
-int
-operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline int
+operator()(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__)  const 
 {
 return first_capture(y_i, pstream__);
 }
 };
 
-int
-last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline int
+last_capture(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -15376,20 +15387,19 @@ last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
 }
 
 struct last_capture_functor__ {
-int
-operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline int
+operator()(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__)  const 
 {
 return last_capture(y_i, pstream__);
 }
 };
 
 template <typename T2__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T2__>,
-stan::value_type_t<T3__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T2__, T3__>, -1, -1>
 prob_uncaptured(const int& nind, const int& n_occasions, const T2__& p_arg__,
                 const T3__& phi_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T2__>,
-          stan::value_type_t<T3__>>;
+  using local_scalar_t__ = stan::return_type_t<T2__, T3__>;
   int current_statement__ = 0; 
   const auto& p = to_ref(p_arg__);
   const auto& phi = to_ref(phi_arg__);
@@ -15507,8 +15517,7 @@ prob_uncaptured(const int& nind, const int& n_occasions, const T2__& p_arg__,
 
 struct prob_uncaptured_functor__ {
 template <typename T2__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T2__>,
-stan::value_type_t<T3__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T2__, T3__>, -1, -1>
 operator()(const int& nind, const int& n_occasions, const T2__& p,
            const T3__& phi, std::ostream* pstream__)  const 
 {
@@ -17478,9 +17487,10 @@ static constexpr std::array<const char*, 144> locations_array__ =
  " (in 'inlining-fail2.stan', line 157, column 4 to column 26)"};
 
 
-int
-first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline int
+first_capture(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -17517,16 +17527,18 @@ first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
 }
 
 struct first_capture_functor__ {
-int
-operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline int
+operator()(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__)  const 
 {
 return first_capture(y_i, pstream__);
 }
 };
 
-int
-last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline int
+last_capture(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -17569,20 +17581,19 @@ last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
 }
 
 struct last_capture_functor__ {
-int
-operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline int
+operator()(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__)  const 
 {
 return last_capture(y_i, pstream__);
 }
 };
 
 template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>,
-stan::value_type_t<T1__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__>, -1, -1>
 prob_uncaptured(const T0__& p_arg__, const T1__& phi_arg__,
                 std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>,
-          stan::value_type_t<T1__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__>;
   int current_statement__ = 0; 
   const auto& p = to_ref(p_arg__);
   const auto& phi = to_ref(phi_arg__);
@@ -17701,26 +17712,25 @@ prob_uncaptured(const T0__& p_arg__, const T1__& phi_arg__,
 
 struct prob_uncaptured_functor__ {
 template <typename T0__, typename T1__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>,
-stan::value_type_t<T1__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T0__, T1__>, -1, -1>
 operator()(const T0__& p, const T1__& phi, std::ostream* pstream__)  const 
 {
 return prob_uncaptured(p, phi, pstream__);
 }
 };
 
-template <bool propto__, typename T3__, typename T4__, typename T5__,
-typename T6__, typename T_lp__, typename T_lp_accum__>
-void
-jolly_seber_lp(const std::vector<std::vector<int>>& y,
-               const std::vector<int>& first, const std::vector<int>& last,
-               const T3__& p_arg__, const T4__& phi_arg__,
-               const T5__& gamma_arg__, const T6__& chi_arg__, T_lp__& lp__,
-               T_lp_accum__& lp_accum__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T3__>,
-          stan::value_type_t<T4__>,
-          stan::value_type_t<T5__>,
-          stan::value_type_t<T6__>>;
+template <bool propto__, typename T0__, typename Alloc0__, typename T1__,
+typename Alloc1__, typename T2__, typename Alloc2__, typename T3__,
+typename T4__, typename T5__, typename T6__, typename T_lp__,
+typename T_lp_accum__>
+inline void
+jolly_seber_lp(const std::vector<T0__, Alloc0__>& y,
+               const std::vector<T1__, Alloc1__>& first,
+               const std::vector<T2__, Alloc2__>& last, const T3__& p_arg__,
+               const T4__& phi_arg__, const T5__& gamma_arg__,
+               const T6__& chi_arg__, T_lp__& lp__, T_lp_accum__& lp_accum__,
+               std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__, T4__, T5__, T6__>;
   int current_statement__ = 0; 
   const auto& p = to_ref(p_arg__);
   const auto& phi = to_ref(phi_arg__);
@@ -18152,14 +18162,16 @@ jolly_seber_lp(const std::vector<std::vector<int>>& y,
 }
 
 struct jolly_seber_lp_functor__ {
-template <bool propto__, typename T3__, typename T4__, typename T5__,
-typename T6__, typename T_lp__, typename T_lp_accum__>
-void
-operator()(const std::vector<std::vector<int>>& y,
-           const std::vector<int>& first, const std::vector<int>& last,
-           const T3__& p, const T4__& phi, const T5__& gamma,
-           const T6__& chi, T_lp__& lp__, T_lp_accum__& lp_accum__,
-           std::ostream* pstream__)  const 
+template <bool propto__, typename T0__, typename Alloc0__, typename T1__,
+typename Alloc1__, typename T2__, typename Alloc2__, typename T3__,
+typename T4__, typename T5__, typename T6__, typename T_lp__,
+typename T_lp_accum__>
+inline void
+operator()(const std::vector<T0__, Alloc0__>& y,
+           const std::vector<T1__, Alloc1__>& first,
+           const std::vector<T2__, Alloc2__>& last, const T3__& p,
+           const T4__& phi, const T5__& gamma, const T6__& chi, T_lp__& lp__,
+           T_lp_accum__& lp_accum__, std::ostream* pstream__)  const 
 {
 return jolly_seber_lp<propto__>(y, first, last, p, phi, gamma, chi, lp__,
          lp_accum__, pstream__);
@@ -18167,9 +18179,9 @@ return jolly_seber_lp<propto__>(y, first, last, p, phi, gamma, chi, lp__,
 };
 
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, 1>
 seq_cprob(const T0__& gamma_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   const auto& gamma = to_ref(gamma_arg__);
   static constexpr bool propto__ = true;
@@ -18225,7 +18237,7 @@ seq_cprob(const T0__& gamma_arg__, std::ostream* pstream__) {
 
 struct seq_cprob_functor__ {
 template <typename T0__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>>, -1, 1>
+inline Eigen::Matrix<stan::return_type_t<T0__>, -1, 1>
 operator()(const T0__& gamma, std::ostream* pstream__)  const 
 {
 return seq_cprob(gamma, pstream__);
@@ -21833,9 +21845,10 @@ static constexpr std::array<const char*, 64> locations_array__ =
  " (in 'lcm-fails2.stan', line 45, column 4 to column 15)"};
 
 
-int
-first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline int
+first_capture(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -21872,16 +21885,18 @@ first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
 }
 
 struct first_capture_functor__ {
-int
-operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline int
+operator()(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__)  const 
 {
 return first_capture(y_i, pstream__);
 }
 };
 
-int
-last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename Alloc0__>
+inline int
+last_capture(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -21924,20 +21939,19 @@ last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
 }
 
 struct last_capture_functor__ {
-int
-operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+template <typename T0__, typename Alloc0__>
+inline int
+operator()(const std::vector<T0__, Alloc0__>& y_i, std::ostream* pstream__)  const 
 {
 return last_capture(y_i, pstream__);
 }
 };
 
 template <typename T2__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T2__>,
-stan::value_type_t<T3__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T2__, T3__>, -1, -1>
 prob_uncaptured(const int& nind, const int& n_occasions, const T2__& p_arg__,
                 const T3__& phi_arg__, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T2__>,
-          stan::value_type_t<T3__>>;
+  using local_scalar_t__ = stan::return_type_t<T2__, T3__>;
   int current_statement__ = 0; 
   const auto& p = to_ref(p_arg__);
   const auto& phi = to_ref(phi_arg__);
@@ -22055,8 +22069,7 @@ prob_uncaptured(const int& nind, const int& n_occasions, const T2__& p_arg__,
 
 struct prob_uncaptured_functor__ {
 template <typename T2__, typename T3__>
-Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T2__>,
-stan::value_type_t<T3__>>, -1, -1>
+inline Eigen::Matrix<stan::return_type_t<T2__, T3__>, -1, -1>
 operator()(const int& nind, const int& n_occasions, const T2__& p,
            const T3__& phi, std::ostream* pstream__)  const 
 {
@@ -23706,10 +23719,9 @@ static constexpr std::array<const char*, 13> locations_array__ =
 
 
 template <bool propto__, typename T0__, typename T1__>
-stan::promote_args_t<T0__,
-T1__>
+inline auto
 foo_lpdf(const T0__& x, const T1__& mu, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__, T1__>;
+  using local_scalar_t__ = stan::return_type_t<T0__, T1__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -23727,8 +23739,7 @@ foo_lpdf(const T0__& x, const T1__& mu, std::ostream* pstream__) {
 
 struct foo_lpdf_functor__ {
 template <bool propto__, typename T0__, typename T1__>
-stan::promote_args_t<T0__,
-T1__>
+inline auto
 operator()(const T0__& x, const T1__& mu, std::ostream* pstream__)  const 
 {
 return foo_lpdf<propto__>(x, mu, pstream__);
@@ -23736,9 +23747,9 @@ return foo_lpdf<propto__>(x, mu, pstream__);
 };
 
 template <bool propto__, typename T1__>
-stan::promote_args_t<T1__>
+inline auto
 bar_lpmf(const int& n, const T1__& mu, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T1__>;
+  using local_scalar_t__ = stan::return_type_t<T1__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -23756,7 +23767,7 @@ bar_lpmf(const int& n, const T1__& mu, std::ostream* pstream__) {
 
 struct bar_lpmf_functor__ {
 template <bool propto__, typename T1__>
-stan::promote_args_t<T1__>
+inline auto
 operator()(const int& n, const T1__& mu, std::ostream* pstream__)  const 
 {
 return bar_lpmf<propto__>(n, mu, pstream__);
@@ -23764,9 +23775,9 @@ return bar_lpmf<propto__>(n, mu, pstream__);
 };
 
 template <bool propto__, typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 baz_lpdf(const T0__& x, std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -23784,7 +23795,7 @@ baz_lpdf(const T0__& x, std::ostream* pstream__) {
 
 struct baz_lpdf_functor__ {
 template <bool propto__, typename T0__>
-stan::promote_args_t<T0__>
+inline auto
 operator()(const T0__& x, std::ostream* pstream__)  const 
 {
 return baz_lpdf<propto__>(x, pstream__);
@@ -26080,10 +26091,10 @@ static constexpr std::array<const char*, 93> locations_array__ =
 
 template <bool propto__, typename T0__, typename T_lp__,
 typename T_lp_accum__>
-void
+inline void
 nrfun_lp(const T0__& x, const int& y, T_lp__& lp__, T_lp_accum__& lp_accum__,
          std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  using local_scalar_t__ = stan::return_type_t<T0__>;
   int current_statement__ = 0; 
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
@@ -26107,7 +26118,7 @@ nrfun_lp(const T0__& x, const int& y, T_lp__& lp__, T_lp_accum__& lp_accum__,
 struct nrfun_lp_functor__ {
 template <bool propto__, typename T0__, typename T_lp__,
 typename T_lp_accum__>
-void
+inline void
 operator()(const T0__& x, const int& y, T_lp__& lp__,
            T_lp_accum__& lp_accum__, std::ostream* pstream__)  const 
 {
@@ -26115,9 +26126,9 @@ return nrfun_lp<propto__>(x, y, lp__, lp_accum__, pstream__);
 }
 };
 
-int
+inline int
 rfun(const int& y, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+  using local_scalar_t__ = stan::return_type_t<>;
   int current_statement__ = 0; 
   static constexpr bool propto__ = true;
   (void) propto__;
@@ -26143,7 +26154,7 @@ rfun(const int& y, std::ostream* pstream__) {
 }
 
 struct rfun_functor__ {
-int
+inline int
 operator()(const int& y, std::ostream* pstream__)  const 
 {
 return rfun(y, pstream__);
@@ -26151,7 +26162,7 @@ return rfun(y, pstream__);
 };
 
 template <bool propto__, typename T_lp__, typename T_lp_accum__>
-int
+inline int
 rfun_lp(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) {
   using local_scalar_t__ = double;
   int current_statement__ = 0; 
@@ -26172,7 +26183,7 @@ rfun_lp(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) {
 
 struct rfun_lp_functor__ {
 template <bool propto__, typename T_lp__, typename T_lp_accum__>
-int
+inline int
 operator()(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__)  const 
 {
 return rfun_lp<propto__>(lp__, lp_accum__, pstream__);
diff --git a/test/unit/Stan_math_code_gen_tests.ml b/test/unit/Stan_math_code_gen_tests.ml
index b9b3b97cf1..bfc4dff570 100644
--- a/test/unit/Stan_math_code_gen_tests.ml
+++ b/test/unit/Stan_math_code_gen_tests.ml
@@ -28,10 +28,9 @@ let%expect_test "udf" =
   [%expect
     {|
     template <typename T0__, typename T1__>
-    void
+    inline void
     sars(const T0__& x_arg__, const T1__& y_arg__, std::ostream* pstream__) {
-      using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>,
-              stan::value_type_t<T1__>>;
+      using local_scalar_t__ = stan::return_type_t<T0__, T1__>;
       int current_statement__ = 0;
       const auto& x = to_ref(x_arg__);
       const auto& y = to_ref(y_arg__);
@@ -49,7 +48,7 @@ let%expect_test "udf" =
 
     struct sars_functor__ {
     template <typename T0__, typename T1__>
-    void
+    inline void
     operator()(const T0__& x, const T1__& y, std::ostream* pstream__)  const
     {
     return sars(x, y, pstream__);
@@ -81,17 +80,12 @@ let%expect_test "udf-expressions" =
   |> print_endline ;
   [%expect
     {|
-    template <typename T0__, typename T1__, typename T2__, typename T3__>
-    Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>, stan::value_type_t<T1__>,
-    stan::value_type_t<T2__>,
-    T3__>, -1, -1>
+    template <typename T0__, typename T1__, typename T2__, typename T3__,
+    typename Alloc3__>
+    inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, -1>
     sars(const T0__& x_arg__, const T1__& y_arg__, const T2__& z_arg__,
-         const std::vector<Eigen::Matrix<T3__, -1, -1>>& w,
-         std::ostream* pstream__) {
-      using local_scalar_t__ = stan::promote_args_t<stan::value_type_t<T0__>,
-              stan::value_type_t<T1__>,
-              stan::value_type_t<T2__>,
-              T3__>;
+         const std::vector<T3__, Alloc3__>& w, std::ostream* pstream__) {
+      using local_scalar_t__ = stan::return_type_t<T0__, T1__, T2__, T3__>;
       int current_statement__ = 0;
       const auto& x = to_ref(x_arg__);
       const auto& y = to_ref(y_arg__);
@@ -109,13 +103,11 @@ let%expect_test "udf-expressions" =
     }
 
     struct sars_functor__ {
-    template <typename T0__, typename T1__, typename T2__, typename T3__>
-    Eigen::Matrix<stan::promote_args_t<stan::value_type_t<T0__>, stan::value_type_t<T1__>,
-    stan::value_type_t<T2__>,
-    T3__>, -1, -1>
+    template <typename T0__, typename T1__, typename T2__, typename T3__,
+    typename Alloc3__>
+    inline Eigen::Matrix<stan::return_type_t<T0__, T1__, T2__, T3__>, -1, -1>
     operator()(const T0__& x, const T1__& y, const T2__& z,
-               const std::vector<Eigen::Matrix<T3__, -1, -1>>& w,
-               std::ostream* pstream__)  const
+               const std::vector<T3__, Alloc3__>& w, std::ostream* pstream__)  const
     {
     return sars(x, y, z, w, pstream__);
     }