diff --git a/Jenkinsfile b/Jenkinsfile
index 25bb7fa03..6af90acbe 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -25,7 +25,7 @@ def tagName() {
     }
 }
 
-def runPerformanceTests(String testsPath, String stancFlags = ""){
+def runPerformanceTests(String testsPath, String stancFlags = "", Boolean opencl = false){
     unstash 'ubuntu-exe'
 
     sh """
@@ -37,7 +37,6 @@ def runPerformanceTests(String testsPath, String stancFlags = ""){
     utils.checkout_pr("cmdstan", "performance-tests-cmdstan/cmdstan", params.cmdstan_pr)
     utils.checkout_pr("stan", "performance-tests-cmdstan/cmdstan/stan", params.stan_pr)
     utils.checkout_pr("math", "performance-tests-cmdstan/cmdstan/stan/lib/stan_math", params.math_pr)
-
     sh """
         cd performance-tests-cmdstan
         mkdir cmdstan/bin
@@ -48,7 +47,14 @@ def runPerformanceTests(String testsPath, String stancFlags = ""){
     if (stancFlags?.trim()) {
         sh "cd performance-tests-cmdstan/cmdstan && echo 'STANCFLAGS= $stancFlags' >> make/local"
     }
-
+    if (opencl) {
+        sh """
+            cd performance-tests-cmdstan/cmdstan
+            echo STAN_OPENCL=true >> make/local
+            echo OPENCL_PLATFORM_ID=${OPENCL_PLATFORM_ID_GPU} >> make/local
+            echo OPENCL_DEVICE_ID=${OPENCL_DEVICE_ID_GPU} >> make/local
+        """
+    }
     sh """
         cd performance-tests-cmdstan/cmdstan
         echo 'O=0' >> make/local
@@ -82,6 +88,11 @@ pipeline {
         GIT_AUTHOR_EMAIL = 'mc.stanislaw@gmail.com'
         GIT_COMMITTER_NAME = 'Stan Jenkins'
         GIT_COMMITTER_EMAIL = 'mc.stanislaw@gmail.com'
+        OPENCL_DEVICE_ID_CPU = 0
+        OPENCL_DEVICE_ID_GPU = 0
+        OPENCL_PLATFORM_ID = 1
+        OPENCL_PLATFORM_ID_CPU = 0
+        OPENCL_PLATFORM_ID_GPU = 0
     }
     stages {
         stage('Kill previous builds') {
@@ -401,7 +412,79 @@ pipeline {
                     }
                     post { always { runShell("rm -rf ${env.WORKSPACE}/compile-example-O1/*") }}
                 }
+                stage("Compile tests - good with opencl and O=1") {
+                    when {
+                        beforeAgent true
+                        allOf {
+                          expression {
+                            !skipCompileTestsAtO1
+                          }
+                          expression {
+                            !params.skip_compile_O1
+                          }
+                        }
+                    }
+                    agent {
+                        docker {
+                            image 'stanorg/ci:gpu'
+                            label 'linux'
+                        }
+                    }
+                    steps {
+                        dir("${env.WORKSPACE}/compile-good-O1cl"){
+                            unstash "Stanc3Setup"
+                            script {
+                                runPerformanceTests("../test/integration/good", "--O1 --use-opencl", true)
+                            }
 
+                            xunit([GoogleTest(
+                                deleteOutputFiles: false,
+                                failIfNotNew: true,
+                                pattern: 'performance-tests-cmdstan/performance.xml',
+                                skipNoTestFiles: false,
+                                stopProcessingIfError: false)
+                            ])
+                        }
+                    }
+                    post { always { runShell("rm -rf ${env.WORKSPACE}/compile-good-O1cl/*") }}
+                }
+
+                stage("Compile tests - example-models with opencl and O=1") {
+                    when {
+                        beforeAgent true
+                        allOf {
+                          expression {
+                            !skipCompileTestsAtO1
+                          }
+                          expression {
+                            !params.skip_compile_O1
+                          }
+                        }
+                    }
+                    agent {
+                        docker {
+                            image 'stanorg/ci:gpu'
+                            label 'linux'
+                        }
+                    }
+                    steps {
+                        dir("${env.WORKSPACE}/compile-example-O1cl"){   
+                            script {
+                                unstash "Stanc3Setup"
+                                runPerformanceTests("example-models", "--O1 --use-opencl", true)
+                            }
+
+                            xunit([GoogleTest(
+                                deleteOutputFiles: false,
+                                failIfNotNew: true,
+                                pattern: 'performance-tests-cmdstan/performance.xml',
+                                skipNoTestFiles: false,
+                                stopProcessingIfError: false)
+                            ])
+                        }
+                    }
+                    post { always { runShell("rm -rf ${env.WORKSPACE}/compile-example-O1cl/*") }}
+                }
                 stage("Model end-to-end tests") {
                     when {
                         beforeAgent true
diff --git a/src/analysis_and_optimization/Debug_data_generation.ml b/src/analysis_and_optimization/Debug_data_generation.ml
index 93c8141eb..3cf1756ac 100644
--- a/src/analysis_and_optimization/Debug_data_generation.ml
+++ b/src/analysis_and_optimization/Debug_data_generation.ml
@@ -264,8 +264,8 @@ and gen_tuple m st t =
 
 and generate_value m st t =
   match st with
-  | SizedType.SInt -> Expr.Helpers.int (gen_num_int m t)
-  | SReal -> Expr.Helpers.float (gen_num_real m t)
+  | SizedType.SInt _ -> Expr.Helpers.int (gen_num_int m t)
+  | SReal _ -> Expr.Helpers.float (gen_num_real m t)
   | SComplex -> gen_complex ()
   | SVector (_, e) -> gen_vector m (unwrap_int_exn m e) t
   | SRowVector (_, e) -> gen_row_vector m (unwrap_int_exn m e) t
@@ -275,7 +275,7 @@ and generate_value m st t =
   | SComplexRowVector e -> gen_complex_row_vector (unwrap_int_exn m e)
   | SComplexMatrix (e1, e2) ->
       gen_complex_matrix (unwrap_int_exn m e1) (unwrap_int_exn m e2)
-  | SArray (st, e) -> gen_array m st (unwrap_int_exn m e) t
+  | SArray (_, st, e) -> gen_array m st (unwrap_int_exn m e) t
   | STuple _ -> gen_tuple m st t
 
 let generate_expressions input data =
diff --git a/src/analysis_and_optimization/Memory_patterns.ml b/src/analysis_and_optimization/Memory_patterns.ml
index 281bfc575..17f50e2b8 100644
--- a/src/analysis_and_optimization/Memory_patterns.ml
+++ b/src/analysis_and_optimization/Memory_patterns.ml
@@ -2,6 +2,29 @@ open Core_kernel
 open Core_kernel.Poly
 open Middle
 
+let user_warning (mem_pattern : Mem_pattern.t) (linenum : int) (msg : string) =
+  let mem_name =
+    match mem_pattern with
+    | Mem_pattern.SoA -> "SoA"
+    | OpenCL -> "OpenCL"
+    | AoS -> "AoS" in
+  Printf.eprintf "%s (Line: %i) warning: %s\n" mem_name linenum msg
+
+let user_warning_op (mem_pattern : Mem_pattern.t) (linenum : int) (msg : string)
+    (names : string) =
+  let mem_name =
+    match mem_pattern with
+    | Mem_pattern.SoA -> "SoA"
+    | OpenCL -> "OpenCL"
+    | AoS -> "AoS" in
+  if String.is_empty names || String.is_empty msg then Printf.eprintf ""
+  else Printf.eprintf "%s (Line %i) warning: %s\n" mem_name linenum (msg ^ names)
+
+let concat_set_str (set : string Set.Poly.t) =
+  Set.Poly.fold
+    ~f:(fun acc elem -> if acc = "" then acc ^ elem else acc ^ ", " ^ elem)
+    ~init:"" set
+
 (**
   Return a Var expression of the name for each type
    containing an eigen matrix
@@ -84,8 +107,8 @@ let rec is_uni_eigen_loop_indexing in_loop (ut : UnsizedType.t)
         | None -> false )
       | _ -> false )
 
-let query_stan_math_mem_pattern_support (name : string)
-    (args : (UnsizedType.autodifftype * UnsizedType.t) list) =
+let query_stan_math_mem_pattern_support (requested_mem : Mem_pattern.t)
+    (name : string) (args : (UnsizedType.autodifftype * UnsizedType.t) list) =
   let open Stan_math_signatures in
   match name with
   | x when is_stan_math_variadic_function_name x -> false
@@ -103,13 +126,16 @@ let query_stan_math_mem_pattern_support (name : string)
             |> Result.is_ok )
           namematches in
       let is_soa ((_ : UnsizedType.returntype), _, mem) =
-        mem = Mem_pattern.SoA in
+        match requested_mem with
+        | Mem_pattern.SoA -> mem = Mem_pattern.SoA || mem = OpenCL
+        | OpenCL -> mem = OpenCL
+        | AoS -> mem = AoS in
       List.exists ~f:is_soa filteredmatches
 
 (*Validate whether a function can support SoA matrices*)
-let is_fun_soa_supported name exprs =
+let is_fun_soa_supported (requested_mem : Mem_pattern.t) name exprs =
   let fun_args = List.map ~f:Expr.Typed.fun_arg exprs in
-  query_stan_math_mem_pattern_support name fun_args
+  query_stan_math_mem_pattern_support requested_mem name fun_args
 
 (**
   Query to find the initial set of objects that cannot be SoA.
@@ -121,13 +147,16 @@ let is_fun_soa_supported name exprs =
     will be returned if the matrix or vector is accessed by single
      cell indexing.
  *)
-let rec query_initial_demotable_expr (in_loop : bool) ~(acc : string Set.Poly.t)
+let rec query_initial_demotable_expr (requested_mem : Mem_pattern.t)
+    (in_loop : bool) (stmt_linenum : int) ~(acc : string Set.Poly.t)
     Expr.Fixed.{pattern; _} : string Set.Poly.t =
   let query_expr (accum : string Set.Poly.t) =
-    query_initial_demotable_expr in_loop ~acc:accum in
+    query_initial_demotable_expr requested_mem in_loop stmt_linenum ~acc:accum
+  in
   match pattern with
   | FunApp (kind, (exprs : Expr.Typed.t list)) ->
-      query_initial_demotable_funs in_loop acc kind exprs
+      query_initial_demotable_funs requested_mem in_loop stmt_linenum acc kind
+        exprs
   | Indexed ((Expr.Fixed.{meta= {type_; _}; _} as expr), indexed) ->
       let index_set =
         Set.Poly.union_list
@@ -138,7 +167,12 @@ let rec query_initial_demotable_expr (in_loop : bool) ~(acc : string Set.Poly.t)
              indexed ) in
       let index_demotes =
         if is_uni_eigen_loop_indexing in_loop type_ indexed then
-          Set.Poly.union (query_var_eigen_names expr) index_set
+          let single_index_set = query_var_eigen_names expr in
+          let failure_str =
+            concat_set_str (Set.Poly.inter acc single_index_set) in
+          let msg = "Accessed by element in a for loop: " in
+          let () = user_warning_op requested_mem stmt_linenum msg failure_str in
+          Set.Poly.union single_index_set index_set
         else Set.Poly.union (query_expr acc expr) index_set in
       Set.Poly.union acc index_demotes
   | Var (_ : string) | Lit ((_ : Expr.Fixed.Pattern.litType), (_ : string)) ->
@@ -147,9 +181,16 @@ let rec query_initial_demotable_expr (in_loop : bool) ~(acc : string Set.Poly.t)
   | TupleProjection (expr, _) -> query_expr acc expr
   | TernaryIf (predicate, texpr, fexpr) ->
       let predicate_demotes = query_expr acc predicate in
-      Set.Poly.union
-        (Set.Poly.union predicate_demotes (query_var_eigen_names texpr))
-        (query_var_eigen_names fexpr)
+      let full_set =
+        Set.Poly.union
+          (Set.Poly.union predicate_demotes (query_var_eigen_names texpr))
+          (query_var_eigen_names fexpr) in
+      if Set.Poly.is_empty full_set then full_set
+      else
+        let failure_str = concat_set_str (Set.Poly.inter acc full_set) in
+        let msg = "Used in a ternary operator which is not allowed: " in
+        let () = user_warning_op requested_mem stmt_linenum msg failure_str in
+        full_set
   | EAnd (lhs, rhs) | EOr (lhs, rhs) ->
       (*We need to get the demotes from both sides*)
       let full_lhs_rhs =
@@ -173,9 +214,12 @@ let rec query_initial_demotable_expr (in_loop : bool) ~(acc : string Set.Poly.t)
    to the UDF.
   exprs The expression list passed to the functions.
  *)
-and query_initial_demotable_funs (in_loop : bool) (acc : string Set.Poly.t)
+and query_initial_demotable_funs (requested_mem : Mem_pattern.t)
+    (in_loop : bool) (stmt_linenum : int) (acc : string Set.Poly.t)
     (kind : 'a Fun_kind.t) (exprs : Expr.Typed.t list) : string Set.Poly.t =
-  let query_expr accum = query_initial_demotable_expr in_loop ~acc:accum in
+  let query_expr accum =
+    query_initial_demotable_expr requested_mem in_loop stmt_linenum ~acc:accum
+  in
   let top_level_eigen_names =
     Set.Poly.union_list (List.map ~f:query_var_eigen_names exprs) in
   let demoted_eigen_names = List.fold ~init:acc ~f:query_expr exprs in
@@ -186,13 +230,31 @@ and query_initial_demotable_funs (in_loop : bool) (acc : string Set.Poly.t)
     match name with
     | "check_matching_dims" -> acc
     | name -> (
-      match is_fun_soa_supported name exprs with
+      match is_fun_soa_supported requested_mem name exprs with
       | true -> Set.Poly.union acc demoted_eigen_names
-      | false -> Set.Poly.union acc demoted_and_top_level_names ) )
+      | false ->
+          let fail_names =
+            concat_set_str (Set.Poly.inter acc top_level_eigen_names) in
+          let () =
+            user_warning_op requested_mem stmt_linenum
+              ("Function " ^ name ^ " is not supported: ")
+              fail_names in
+          Set.Poly.union acc demoted_and_top_level_names ) )
   | CompilerInternal (Internal_fun.FnMakeArray | FnMakeRowVec) ->
+      let fail_names =
+        concat_set_str (Set.Poly.inter acc demoted_and_top_level_names) in
+      let () =
+        user_warning_op requested_mem stmt_linenum
+          "Used in {} make array or make row vector compiler functions: "
+          fail_names in
       Set.Poly.union acc demoted_and_top_level_names
   | CompilerInternal (_ : 'a Internal_fun.t) -> acc
   | UserDefined ((_ : string), (_ : bool Fun_kind.suffix)) ->
+      let fail_names =
+        concat_set_str (Set.Poly.inter acc demoted_and_top_level_names) in
+      let () =
+        user_warning_op requested_mem stmt_linenum
+          "Used in user defined function:" fail_names in
       Set.Poly.union acc demoted_and_top_level_names
 
 (** 
@@ -289,10 +351,12 @@ let contains_at_least_one_ad_matrix_or_all_data
   @param in_loop A boolean to specify the logic of indexing expressions. See
    [query_initial_demotable_expr] for an explanation of the logic.
  *)
-let rec query_initial_demotable_stmt (in_loop : bool) (acc : string Set.Poly.t)
-    (Stmt.Fixed.{pattern; _} : Stmt.Located.t) : string Set.Poly.t =
+let rec query_initial_demotable_stmt (requested_mem : Mem_pattern.t)
+    (in_loop : bool) (acc : string Set.Poly.t)
+    (Stmt.Fixed.{pattern; meta} : Stmt.Located.t) : string Set.Poly.t =
+  let linenum = meta.end_loc.line_num in
   let query_expr (accum : string Set.Poly.t) =
-    query_initial_demotable_expr in_loop ~acc:accum in
+    query_initial_demotable_expr requested_mem in_loop linenum ~acc:accum in
   match pattern with
   | Stmt.Fixed.Pattern.Assignment
       ( lval
@@ -306,11 +370,18 @@ let rec query_initial_demotable_stmt (in_loop : bool) (acc : string Set.Poly.t)
           List.fold ~init:acc
             ~f:(fun accum x ->
               Index.folder accum
-                (fun acc -> query_initial_demotable_expr in_loop ~acc)
+                (fun acc ->
+                  query_initial_demotable_expr requested_mem in_loop linenum
+                    ~acc )
                 x )
             idx in
         match is_uni_eigen_loop_indexing in_loop ut idx with
-        | true -> Set.Poly.add idx_list name
+        | true ->
+            let () =
+              user_warning_op requested_mem linenum
+                "Accessed by element in a for loop: "
+                (if Set.Poly.mem acc name then "" else name) in
+            Set.Poly.add idx_list name
         | false -> idx_list in
       let rhs_demotable_names = query_expr acc rhs in
       let rhs_and_idx_demotions =
@@ -319,9 +390,12 @@ let rec query_initial_demotable_stmt (in_loop : bool) (acc : string Set.Poly.t)
       let tuple_demotions =
         match lval with
         | LTupleProjection _, _ ->
-            Set.Poly.add
-              (Set.Poly.union rhs_and_idx_demotions (query_var_eigen_names rhs))
-              name
+            let tuple_set = query_var_eigen_names rhs in
+            let fail_set = concat_set_str tuple_set in
+            let () =
+              user_warning_op requested_mem linenum "Used in tuple: " fail_set
+            in
+            Set.Poly.add (Set.Poly.union rhs_and_idx_demotions tuple_set) name
         | _ -> rhs_and_idx_demotions in
       let assign_demotions =
         let is_eigen_stmt = UnsizedType.contains_eigen_type rhs.meta.type_ in
@@ -341,7 +415,7 @@ let rec query_initial_demotable_stmt (in_loop : bool) (acc : string Set.Poly.t)
             | FunApp (CompilerInternal _, _) -> false
             | FunApp (StanLib (name, _, _), exprs) ->
                 not
-                  (query_stan_math_mem_pattern_support name
+                  (query_stan_math_mem_pattern_support requested_mem name
                      (List.map ~f:Expr.Typed.fun_arg exprs) )
             | _ -> false in
           (* LHS (3) all rhs aos*)
@@ -353,28 +427,57 @@ let rec query_initial_demotable_stmt (in_loop : bool) (acc : string Set.Poly.t)
             is_all_rhs_aos || is_rhs_not_promoteable_to_soa
             || is_not_supported_func
           then
-            Set.Poly.add
-              (Set.Poly.union tuple_demotions (query_var_eigen_names rhs))
-              name
+            let rhs_set = query_var_eigen_names rhs in
+            let all_rhs_warn =
+              if is_all_rhs_aos then
+                "Right hand side of assignment is all AoS: "
+              else "" in
+            let rhs_not_promotable_to_soa_warn =
+              if is_rhs_not_promoteable_to_soa then
+                "The right hand side of the assignment only contains data and \
+                 scalar operations that are not promotable to SoA: "
+              else "" in
+            let not_supported_func_warn =
+              if is_not_supported_func then
+                "Function on right hand side of assignment is not supported by \
+                 SoA: "
+              else "" in
+            let rhs_name_set = Set.Poly.add rhs_set name in
+            let rhs_name_set_str = concat_set_str rhs_name_set in
+            let () =
+              user_warning_op requested_mem linenum all_rhs_warn
+                rhs_name_set_str in
+            let () =
+              user_warning_op requested_mem linenum
+                rhs_not_promotable_to_soa_warn rhs_name_set_str in
+            let () =
+              user_warning_op requested_mem linenum not_supported_func_warn
+                rhs_name_set_str in
+            Set.Poly.add (Set.Poly.union tuple_demotions rhs_set) name
           else tuple_demotions
         else tuple_demotions in
       Set.Poly.union acc assign_demotions
   | NRFunApp (kind, exprs) ->
-      query_initial_demotable_funs in_loop acc kind exprs
+      query_initial_demotable_funs requested_mem in_loop linenum acc kind exprs
   | IfElse (predicate, true_stmt, op_false_stmt) ->
       let predicate_acc = query_expr acc predicate in
       Set.Poly.union acc
         (Set.Poly.union_list
            [ predicate_acc
-           ; query_initial_demotable_stmt in_loop predicate_acc true_stmt
+           ; query_initial_demotable_stmt requested_mem in_loop predicate_acc
+               true_stmt
            ; Option.value_map
-               ~f:(query_initial_demotable_stmt in_loop predicate_acc)
+               ~f:
+                 (query_initial_demotable_stmt requested_mem in_loop
+                    predicate_acc )
                ~default:Set.Poly.empty op_false_stmt ] )
   | Return optional_expr ->
       Option.value_map ~f:(query_expr acc) ~default:Set.Poly.empty optional_expr
   | SList lst | Profile (_, lst) | Block lst ->
       Set.Poly.union_list
-        (List.map ~f:(query_initial_demotable_stmt in_loop acc) lst)
+        (List.map
+           ~f:(query_initial_demotable_stmt requested_mem in_loop acc)
+           lst )
   | TargetPE expr -> query_expr acc expr
   (* NOTE: loops generated by inlining are not actually loops;
      we do not unconditionally set "in_loop" *)
@@ -384,15 +487,15 @@ let rec query_initial_demotable_stmt (in_loop : bool) (acc : string Set.Poly.t)
       ; body
       ; _ }
     when lb = "1" && ub = "1" ->
-      query_initial_demotable_stmt in_loop acc body
+      query_initial_demotable_stmt requested_mem in_loop acc body
   | For {lower; upper; body; _} ->
       Set.Poly.union
         (Set.Poly.union (query_expr acc lower) (query_expr acc upper))
-        (query_initial_demotable_stmt true acc body)
+        (query_initial_demotable_stmt requested_mem true acc body)
   | While (predicate, body) ->
       Set.Poly.union_list
         [ acc; query_expr acc predicate
-        ; query_initial_demotable_stmt true acc body ]
+        ; query_initial_demotable_stmt requested_mem true acc body ]
   | Decl {decl_type= Type.Sized st; decl_id; _}
     when SizedType.is_complex_type st ->
       Set.Poly.add acc decl_id
@@ -410,7 +513,8 @@ let rec query_initial_demotable_stmt (in_loop : bool) (acc : string Set.Poly.t)
   @param aos_exits A set of variables that can be demoted.
   @param pattern The Stmt pattern to query.
  *)
-let query_demotable_stmt (aos_exits : string Set.Poly.t)
+let query_demotable_stmt (mem_pattern : Mem_pattern.t)
+    (aos_exits : string Set.Poly.t)
     (pattern : (Expr.Typed.t, int) Stmt.Fixed.Pattern.t) : string Set.Poly.t =
   match pattern with
   | Stmt.Fixed.Pattern.Assignment
@@ -418,10 +522,22 @@ let query_demotable_stmt (aos_exits : string Set.Poly.t)
       let assign_name = Stmt.Helpers.lhs_variable lval in
       let all_rhs_eigen_names = query_var_eigen_names rhs in
       if Set.Poly.mem aos_exits assign_name then
-        Set.Poly.add all_rhs_eigen_names assign_name
+        (*idk how to get the line number here :/ *)
+        if not (Set.Poly.mem aos_exits assign_name) then
+          let () =
+            user_warning_op mem_pattern 1
+              "Right hand side contains only AoS expressions: " assign_name
+          in
+          Set.Poly.add all_rhs_eigen_names assign_name
+        else Set.Poly.add all_rhs_eigen_names assign_name
       else
         match is_nonzero_subset ~set:aos_exits ~subset:all_rhs_eigen_names with
-        | true -> Set.Poly.add all_rhs_eigen_names assign_name
+        | true ->
+            let () =
+              user_warning_op mem_pattern 1
+                "Right hand side contains only AoS expressions: " assign_name
+            in
+            Set.Poly.add all_rhs_eigen_names assign_name
         | false -> Set.Poly.empty )
   (* All other statements do not need logic here*)
   | _ -> Set.Poly.empty
@@ -441,29 +557,41 @@ let query_demotable_stmt (aos_exits : string Set.Poly.t)
   @param kind A [Fun_kind.t]
   @param exprs A list of expressions going into the function.
  **)
-let rec modify_kind ?force_demotion:(force = false)
-    (modifiable_set : string Set.Poly.t) (kind : 'a Fun_kind.t)
-    (exprs : Expr.Typed.t list) =
+let rec modify_kind (requested_mem : Mem_pattern.t)
+    ?force_demotion:(force = false) (modifiable_set : string Set.Poly.t)
+    (kind : 'a Fun_kind.t) (exprs : Expr.Typed.t list) =
   let expr_names =
     Set.Poly.union_list (List.map ~f:query_var_eigen_names exprs) in
   let is_all_in_list =
     is_nonzero_subset ~set:modifiable_set ~subset:expr_names in
   match kind with
   | Fun_kind.StanLib (name, sfx, (_ : Mem_pattern.t)) ->
-      if is_all_in_list || (not (is_fun_soa_supported name exprs)) || force then
+      if
+        is_all_in_list
+        || (not (is_fun_soa_supported requested_mem name exprs))
+        || force
+      then
         (*Force demotion of all subexprs*)
         let exprs' =
-          List.map ~f:(modify_expr ~force_demotion:true expr_names) exprs in
+          List.map
+            ~f:(modify_expr requested_mem ~force_demotion:true expr_names)
+            exprs in
         (Fun_kind.StanLib (name, sfx, Mem_pattern.AoS), exprs')
       else
-        ( Fun_kind.StanLib (name, sfx, SoA)
-        , List.map ~f:(modify_expr ~force_demotion:force modifiable_set) exprs
-        )
+        ( Fun_kind.StanLib (name, sfx, requested_mem)
+        , List.map
+            ~f:(modify_expr requested_mem ~force_demotion:force modifiable_set)
+            exprs )
   | UserDefined _ as udf ->
-      (udf, List.map ~f:(modify_expr ~force_demotion:force modifiable_set) exprs)
+      ( udf
+      , List.map
+          ~f:(modify_expr requested_mem ~force_demotion:force modifiable_set)
+          exprs )
   | (_ : 'a Fun_kind.t) ->
       ( kind
-      , List.map ~f:(modify_expr ~force_demotion:force modifiable_set) exprs )
+      , List.map
+          ~f:(modify_expr requested_mem ~force_demotion:force modifiable_set)
+          exprs )
 
 (**
   Modify an expression and it's subexpressions from SoA <-> AoS
@@ -479,15 +607,16 @@ let rec modify_kind ?force_demotion:(force = false)
    associated expressions we want to modify.
   @param pattern The expression to modify.
  *)
-and modify_expr_pattern ?force_demotion:(force = false)
-    (modifiable_set : string Set.Poly.t)
+and modify_expr_pattern (requested_mem : Mem_pattern.t)
+    ?force_demotion:(force = false) (modifiable_set : string Set.Poly.t)
     (pattern : Expr.Typed.t Expr.Fixed.Pattern.t) =
   let mod_expr ?force_demotion:(forced = false) =
-    modify_expr ~force_demotion:forced modifiable_set in
+    modify_expr requested_mem ~force_demotion:forced modifiable_set in
   match pattern with
   | Expr.Fixed.Pattern.FunApp (kind, (exprs : Expr.Typed.t list)) ->
       let kind', expr' =
-        modify_kind ~force_demotion:force modifiable_set kind exprs in
+        modify_kind requested_mem ~force_demotion:force modifiable_set kind
+          exprs in
       Expr.Fixed.Pattern.FunApp (kind', expr')
   | TernaryIf (predicate, texpr, fexpr) ->
       let is_eigen_return =
@@ -523,10 +652,12 @@ and modify_expr_pattern ?force_demotion:(force = false)
    associated expressions we want to modify.
   @param expr the expression to modify.
 *)
-and modify_expr ?force_demotion:(force = false)
+and modify_expr (requested_mem : Mem_pattern.t) ?force_demotion:(force = false)
     (modifiable_set : string Set.Poly.t) (Expr.Fixed.{pattern; _} as expr) =
   { expr with
-    pattern= modify_expr_pattern ~force_demotion:force modifiable_set pattern }
+    pattern=
+      modify_expr_pattern requested_mem ~force_demotion:force modifiable_set
+        pattern }
 
 (**
   Modify statement patterns in the MIR from AoS <-> SoA and vice versa
@@ -540,11 +671,12 @@ and modify_expr ?force_demotion:(force = false)
   @param pattern The statement pattern to modify
   @param modifiable_set The name of the variable we are searching for.
 *)
-let rec modify_stmt_pattern
+let rec modify_stmt_pattern (requested_mem : Mem_pattern.t)
     (pattern : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t)
     (modifiable_set : string Core_kernel.Set.Poly.t) =
-  let mod_expr force = modify_expr ~force_demotion:force modifiable_set in
-  let mod_stmt stmt = modify_stmt stmt modifiable_set in
+  let mod_expr force =
+    modify_expr requested_mem ~force_demotion:force modifiable_set in
+  let mod_stmt stmt = modify_stmt requested_mem stmt modifiable_set in
   match pattern with
   | Stmt.Fixed.Pattern.Decl
       ({decl_id; decl_type= Type.Sized sized_type; _} as decl) ->
@@ -557,9 +689,9 @@ let rec modify_stmt_pattern
         Decl
           { decl with
             decl_type=
-              Type.Sized (SizedType.modify_sizedtype_mem SoA sized_type) }
+              Type.Sized (SizedType.promote_mem requested_mem sized_type) }
   | NRFunApp (kind, (exprs : Expr.Typed.t list)) ->
-      let kind', exprs' = modify_kind modifiable_set kind exprs in
+      let kind', exprs' = modify_kind requested_mem modifiable_set kind exprs in
       NRFunApp (kind', exprs')
   | Assignment
       ( lval
@@ -585,7 +717,7 @@ let rec modify_stmt_pattern
               pattern=
                 FunApp
                   ( CompilerInternal
-                      (FnReadParam {read_param with mem_pattern= SoA})
+                      (FnReadParam {read_param with mem_pattern= requested_mem})
                   , List.map ~f:(mod_expr false) args ) } )
   | Assignment (lval, (ut : UnsizedType.t), rhs) ->
       let name = Stmt.Helpers.lhs_variable lval in
@@ -622,9 +754,9 @@ let rec modify_stmt_pattern
   @param stmt The statement to modify.
   @param modifiable_set The name of the variable we are searching for.
 *)
-and modify_stmt (Stmt.Fixed.{pattern; _} as stmt)
-    (modifiable_set : string Set.Poly.t) =
-  {stmt with pattern= modify_stmt_pattern pattern modifiable_set}
+and modify_stmt (requested_mem : Mem_pattern.t)
+    (Stmt.Fixed.{pattern; _} as stmt) (modifiable_set : string Set.Poly.t) =
+  {stmt with pattern= modify_stmt_pattern requested_mem pattern modifiable_set}
 
 let collect_mem_pattern_variables stmts =
   let take_stmt acc = function
@@ -645,3 +777,169 @@ let pp_mem_patterns ppf (Program.{reverse_mode_log_prob; _} : Program.Typed.t) =
     (* Collect all the sizedtypes which have a mem pattern *)
     collect_mem_pattern_variables reverse_mode_log_prob in
   Fmt.(pf ppf "@[<v>%a@.@]" (list pp_var)) mem_vars
+
+let rec extract_opencl_data_expr acc
+    Expr.Fixed.{pattern; meta= Expr.Typed.Meta.{adlevel; _}} =
+  match pattern with
+  | Expr.Fixed.Pattern.FunApp (fun_kind, (exprs : Expr.Typed.t list)) -> (
+    match fun_kind with
+    | Fun_kind.CompilerInternal (Internal_fun.FnReadParam _ : 'a Internal_fun.t)
+      ->
+        acc
+    | _ -> List.fold_left ~f:extract_opencl_data_expr ~init:acc exprs )
+  | TernaryIf (predicate, texpr, fexpr) ->
+      extract_opencl_data_expr
+        (extract_opencl_data_expr (extract_opencl_data_expr acc texpr) fexpr)
+        predicate
+  | Indexed (idx_expr, indexed) ->
+      List.fold_left
+        ~f:(fun acc idx ->
+          Index.apply ~default:acc ~merge:Set.Poly.union
+            (extract_opencl_data_expr acc)
+            idx )
+        ~init:(extract_opencl_data_expr acc idx_expr)
+        indexed
+  | TupleProjection (idx_expr, _) -> extract_opencl_data_expr acc idx_expr
+  | EAnd (lhs, rhs) ->
+      extract_opencl_data_expr (extract_opencl_data_expr acc lhs) rhs
+  | EOr (lhs, rhs) ->
+      extract_opencl_data_expr (extract_opencl_data_expr acc lhs) rhs
+  | Promotion (expr, _, _) -> extract_opencl_data_expr acc expr
+  | Var (name : string) when UnsizedType.is_dataonlytype adlevel ->
+      Set.Poly.add acc name
+  | Var _ | Lit ((_ : Expr.Fixed.Pattern.litType), (_ : string)) -> acc
+
+let rec extract_opencl_data_stmt (acc : string Set.Poly.t)
+    Stmt.Fixed.{pattern; _} =
+  match pattern with
+  | Stmt.Fixed.Pattern.Decl _ -> acc
+  | NRFunApp (_, (exprs : Expr.Typed.t list)) ->
+      List.fold_left ~f:extract_opencl_data_expr ~init:acc exprs
+  | Assignment (_, (_ : UnsizedType.t), rhs) -> extract_opencl_data_expr acc rhs
+  | IfElse (predicate, true_stmt, op_false_stmt) -> (
+      let acc_pred_true =
+        extract_opencl_data_expr
+          (extract_opencl_data_stmt acc true_stmt)
+          predicate in
+      match op_false_stmt with
+      | None -> acc_pred_true
+      | Some false_stmt -> extract_opencl_data_stmt acc_pred_true false_stmt )
+  | Block stmts | SList stmts ->
+      List.fold_left ~f:extract_opencl_data_stmt ~init:acc stmts
+  | For {lower; upper; body; _} ->
+      extract_opencl_data_expr
+        (extract_opencl_data_expr (extract_opencl_data_stmt acc body) upper)
+        lower
+  | TargetPE expr -> extract_opencl_data_expr acc expr
+  | Return optional_expr -> (
+    match optional_expr with
+    | None -> acc
+    | Some expr -> extract_opencl_data_expr acc expr )
+  | Profile ((_ : string), stmts) ->
+      List.fold_left ~f:extract_opencl_data_stmt ~init:acc stmts
+  | While (predicate, body) ->
+      extract_opencl_data_expr (extract_opencl_data_stmt acc body) predicate
+  | Skip | Break | Continue -> acc
+
+let extract_opencl_data (log_prob : Stmt.Located.t list) =
+  List.fold_left ~f:extract_opencl_data_stmt ~init:Set.Poly.empty log_prob
+
+let create_opencl_data names prep_data =
+  let decls =
+    List.filter
+      ~f:(fun Stmt.Fixed.{pattern; _} ->
+        match pattern with Stmt.Fixed.Pattern.Decl _ -> true | _ -> false )
+      prep_data in
+  let make_opencl_decl (Stmt.Fixed.{pattern; _} as stmt) =
+    let new_decl =
+      match pattern with
+      | Decl ({decl_type= Type.Sized st; decl_id; _} as decl)
+        when Set.Poly.mem names decl_id ->
+          let new_decl1 =
+            Stmt.Fixed.Pattern.Decl
+              { decl with
+                decl_type=
+                  Type.Sized
+                    (Middle.SizedType.promote_mem Mem_pattern.OpenCL st)
+              ; decl_id= decl_id ^ "_opencl__" } in
+          let lval_assign = Stmt.Helpers.lvariable (decl_id ^ "_opencl__") in
+          let assign_expr =
+            { Expr.Fixed.meta= Expr.Typed.Meta.empty
+            ; pattern=
+                FunApp
+                  ( StanLib ("to_matrix_cl", FnPlain, OpenCL)
+                  , [Expr.Helpers.variable decl_id] ) } in
+          let new_assign =
+            Stmt.Fixed.Pattern.Assignment
+              (lval_assign, SizedType.to_unsized st, assign_expr) in
+          [new_decl1; new_assign]
+      | _ -> [] in
+    let new_stmts = List.map ~f:(fun x -> {stmt with pattern= x}) new_decl in
+    new_stmts in
+  let new_decls = List.map ~f:make_opencl_decl decls in
+  List.concat [prep_data; List.concat new_decls]
+
+let rec add_opencl_data_expr names (Expr.Fixed.{pattern; _} as expr) =
+  let f = add_opencl_data_expr names in
+  match pattern with
+  | Expr.Fixed.Pattern.FunApp (fun_kind, (exprs : Expr.Typed.t list)) ->
+      { expr with
+        pattern= Expr.Fixed.Pattern.FunApp (fun_kind, List.map ~f exprs) }
+  | TernaryIf (predicate, texpr, fexpr) ->
+      {expr with pattern= TernaryIf (f predicate, f texpr, f fexpr)}
+  | Indexed (idx_expr, indexed) ->
+      { expr with
+        pattern=
+          Indexed
+            (f idx_expr, List.map ~f:(fun x -> Index.map_expr ~f x) indexed) }
+  | TupleProjection (idx_expr, idx) ->
+      {expr with pattern= TupleProjection (f idx_expr, idx)}
+  | EAnd (lhs, rhs) -> {expr with pattern= EAnd (f lhs, f rhs)}
+  | EOr (lhs, rhs) -> {expr with pattern= EOr (f lhs, f rhs)}
+  | Promotion (expr, ut, ad) -> {expr with pattern= Promotion (f expr, ut, ad)}
+  | Var (name : string) when Set.Poly.mem names name ->
+      {expr with pattern= Var (name ^ "_opencl__")}
+  | Var _ | Lit ((_ : Expr.Fixed.Pattern.litType), (_ : string)) -> expr
+
+let rec add_opencl_data_stmt names (Stmt.Fixed.{pattern; _} as stmt) =
+  let f_stmt = add_opencl_data_stmt names in
+  let f_expr = add_opencl_data_expr names in
+  match pattern with
+  | Stmt.Fixed.Pattern.Decl _ -> stmt
+  | NRFunApp (fun_kind, (exprs : Expr.Typed.t list)) ->
+      {stmt with pattern= NRFunApp (fun_kind, List.map ~f:f_expr exprs)}
+  | Assignment (lhs, (ut : UnsizedType.t), rhs) ->
+      {stmt with pattern= Assignment (lhs, ut, f_expr rhs)}
+  | IfElse (predicate, true_stmt, op_false_stmt) -> (
+      let predicate_mod = f_expr predicate in
+      let true_stmt_mod = f_stmt true_stmt in
+      let fin_stmt op_false =
+        {stmt with pattern= IfElse (predicate_mod, true_stmt_mod, op_false)}
+      in
+      match op_false_stmt with
+      | None -> fin_stmt None
+      | Some stmt_some -> fin_stmt (Some (f_stmt stmt_some)) )
+  | Block stmts | SList stmts ->
+      {stmt with pattern= Block (List.map ~f:f_stmt stmts)}
+  | For {loopvar; lower; upper; body} ->
+      { stmt with
+        pattern=
+          For
+            { loopvar
+            ; lower= f_expr lower
+            ; upper= f_expr upper
+            ; body= f_stmt body } }
+  | TargetPE expr -> {stmt with pattern= TargetPE (f_expr expr)}
+  | Return optional_expr -> (
+      let fin_stmt opt = {stmt with pattern= Return opt} in
+      match optional_expr with
+      | None -> fin_stmt None
+      | Some expr -> fin_stmt (Some (f_expr expr)) )
+  | Profile ((name : string), stmts) ->
+      {stmt with pattern= Profile (name, List.map ~f:f_stmt stmts)}
+  | While (predicate, body) ->
+      {stmt with pattern= While (f_expr predicate, f_stmt body)}
+  | Skip | Break | Continue -> stmt
+
+let add_opencl_data names log_prob =
+  List.map ~f:(add_opencl_data_stmt names) log_prob
diff --git a/src/analysis_and_optimization/Mir_utils.ml b/src/analysis_and_optimization/Mir_utils.ml
index 55d51e698..28b537317 100644
--- a/src/analysis_and_optimization/Mir_utils.ml
+++ b/src/analysis_and_optimization/Mir_utils.ml
@@ -84,7 +84,7 @@ let data_set ?(exclude_transformed = false) ?(exclude_ints = false)
   (* Possibly remove ints from the data set *)
   let filtered_data =
     let remove_ints =
-      Set.Poly.filter ~f:(fun (_, _, st) -> st <> SizedType.SInt) in
+      Set.Poly.filter ~f:(fun (_, _, st) -> st <> SizedType.SInt AoS) in
     Set.Poly.map ~f:fst3 ((if exclude_ints then remove_ints else ident) data)
   in
   (* Transformed data are declarations in prepare_data but excluding data *)
@@ -480,10 +480,10 @@ let unsafe_unsized_to_sized_type (rt : Expr.Typed.t Type.t) =
   | Unsized ut ->
       let rec to_sized a =
         match a with
-        | UnsizedType.UReal -> SizedType.SReal
-        | UInt -> SInt
+        | UnsizedType.UReal -> SizedType.SReal AoS
+        | UInt -> SInt AoS
         | UComplex -> SComplex
-        | UArray t -> SArray (to_sized t, Expr.Helpers.int 0)
+        | UArray t -> SArray (AoS, to_sized t, Expr.Helpers.int 0)
         | UMatrix ->
             SMatrix (Mem_pattern.AoS, Expr.Helpers.int 0, Expr.Helpers.int 0)
         | UVector -> SVector (AoS, Expr.Helpers.int 0)
diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml
index 31d87e09f..9e2f1d0d7 100644
--- a/src/analysis_and_optimization/Optimize.ml
+++ b/src/analysis_and_optimization/Optimize.ml
@@ -84,13 +84,12 @@ let gen_inline_var (name : string) (id_var : string) =
 
 let replace_fresh_local_vars (fname : string) stmt =
   let f (m : (string, string) Core_kernel.Map.Poly.t) = function
-    | Stmt.Fixed.Pattern.Decl {decl_adtype; decl_type; decl_id; initialize} ->
+    | Stmt.Fixed.Pattern.Decl ({decl_id; _} as decl_def) ->
         let new_name =
           match Map.Poly.find m decl_id with
           | Some existing -> existing
           | None -> gen_inline_var fname decl_id in
-        ( Stmt.Fixed.Pattern.Decl
-            {decl_adtype; decl_id= new_name; decl_type; initialize}
+        ( Stmt.Fixed.Pattern.Decl {decl_def with decl_id= new_name}
         , Map.Poly.set m ~key:decl_id ~data:new_name )
     | Stmt.Fixed.Pattern.For {loopvar; lower; upper; body} ->
         let new_name =
@@ -200,7 +199,7 @@ let handle_early_returns (fname : string) opt_var stmt =
               Decl
                 { decl_adtype= DataOnly
                 ; decl_id= returned
-                ; decl_type= Sized SInt
+                ; decl_type= Sized (SInt Mem_pattern.AoS)
                 ; initialize= true }
           ; meta= Location_span.empty }
       ; Stmt.Fixed.
@@ -828,7 +827,10 @@ and unenforce_initialize (lst : Stmt.Located.t list) =
     | Stmt.Fixed.Pattern.Decl ({decl_id; decl_type; _} as decl_pat) -> (
         let is_soa =
           match decl_type with
-          | Type.Sized s -> SizedType.get_mem_pattern s = Mem_pattern.SoA
+          | Type.Sized s -> (
+            match SizedType.get_mem_pattern s with
+            | Mem_pattern.SoA | Mem_pattern.OpenCL -> true
+            | _ -> false )
           | _ -> false in
         match List.hd sub_lst with
         | Some next_stmt -> (
@@ -1223,17 +1225,20 @@ let optimize_soa (mir : Program.Typed.t) =
       (l : int) (aos_variables : string Set.Poly.t) =
     let mir_node mir_idx = Map.find_exn flowgraph_to_mir mir_idx in
     match (mir_node l).pattern with
-    | stmt -> Memory_patterns.query_demotable_stmt aos_variables stmt in
+    | stmt ->
+        Memory_patterns.query_demotable_stmt Mem_pattern.SoA aos_variables stmt
+  in
   let initial_variables =
     List.fold ~init:Set.Poly.empty
-      ~f:(Memory_patterns.query_initial_demotable_stmt false)
+      ~f:(Memory_patterns.query_initial_demotable_stmt Mem_pattern.SoA false)
       mir.reverse_mode_log_prob in
   let mod_exprs aos_exits mod_expr =
     Mir_utils.map_rec_expr
-      (Memory_patterns.modify_expr_pattern aos_exits)
+      (Memory_patterns.modify_expr_pattern Mem_pattern.SoA aos_exits)
       mod_expr in
   let modify_stmt_patt stmt_pattern variable_set =
-    Memory_patterns.modify_stmt_pattern stmt_pattern variable_set in
+    Memory_patterns.modify_stmt_pattern Mem_pattern.SoA stmt_pattern
+      variable_set in
   let transform stmt =
     optimize_minimal_variables ~gen_variables:gen_aos_variables
       ~update_expr:mod_exprs ~update_stmt:modify_stmt_patt ~initial_variables
@@ -1247,6 +1252,58 @@ let optimize_soa (mir : Program.Typed.t) =
   in
   {mir with reverse_mode_log_prob= transform' mir.reverse_mode_log_prob}
 
+let optimize_opencl (mir : Program.Typed.t) =
+  let gen_aos_variables
+      (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t)
+      (l : int) (aos_variables : string Set.Poly.t) =
+    let mir_node mir_idx = Map.find_exn flowgraph_to_mir mir_idx in
+    match (mir_node l).pattern with
+    | stmt ->
+        Memory_patterns.query_demotable_stmt Mem_pattern.OpenCL aos_variables
+          stmt in
+  let initial_variables =
+    List.fold ~init:Set.Poly.empty
+      ~f:(Memory_patterns.query_initial_demotable_stmt Mem_pattern.OpenCL false)
+      mir.reverse_mode_log_prob in
+  let mod_exprs aos_exits mod_expr =
+    Mir_utils.map_rec_expr
+      (Memory_patterns.modify_expr_pattern Mem_pattern.OpenCL aos_exits)
+      mod_expr in
+  let modify_stmt_patt stmt_pattern variable_set =
+    Memory_patterns.modify_stmt_pattern Mem_pattern.OpenCL stmt_pattern
+      variable_set in
+  let transform stmt =
+    optimize_minimal_variables ~gen_variables:gen_aos_variables
+      ~update_expr:mod_exprs ~update_stmt:modify_stmt_patt ~initial_variables
+      stmt ~extra_variables:(fun _ -> initial_variables) in
+  let transform' s =
+    match transform {pattern= SList s; meta= Location_span.empty} with
+    | {pattern= SList (l : Stmt.Located.t list); _} -> l
+    | _ ->
+        Common.FatalError.fatal_error_msg
+          [%message "Something went wrong with program transformation packing!"]
+  in
+  let reverse_log_prob = transform' mir.reverse_mode_log_prob in
+  let opencl_data = Memory_patterns.extract_opencl_data reverse_log_prob in
+  let opencl_data_gen =
+    Memory_patterns.create_opencl_data opencl_data mir.prepare_data in
+  let reverse_log_prob' =
+    Memory_patterns.add_opencl_data opencl_data reverse_log_prob in
+  let check_if_all_opencl =
+    List.for_all
+      ~f:(fun stmt ->
+        match stmt.pattern with
+        | Stmt.Fixed.Pattern.Decl {decl_type= Type.Sized st; _}
+          when not (Mem_pattern.is_opencl (SizedType.get_mem_pattern st)) ->
+            false
+        | _ -> true )
+      reverse_log_prob' in
+  if check_if_all_opencl then
+    { mir with
+      reverse_mode_log_prob= reverse_log_prob'
+    ; prepare_data= opencl_data_gen }
+  else mir
+
 (* Apparently you need to completely copy/paste type definitions between
    ml and mli files?*)
 type optimization_settings =
@@ -1264,7 +1321,8 @@ type optimization_settings =
   ; lazy_code_motion: bool
   ; optimize_ad_levels: bool
   ; preserve_stability: bool
-  ; optimize_soa: bool }
+  ; optimize_soa: bool
+  ; optimize_opencl: bool }
 
 let settings_const b =
   { function_inlining= b
@@ -1281,7 +1339,8 @@ let settings_const b =
   ; lazy_code_motion= b
   ; optimize_ad_levels= b
   ; preserve_stability= not b
-  ; optimize_soa= b }
+  ; optimize_soa= b
+  ; optimize_opencl= false }
 
 let all_optimizations : optimization_settings = settings_const true
 let no_optimizations : optimization_settings = settings_const false
@@ -1306,7 +1365,8 @@ let level_optimizations (lvl : optimization_level) : optimization_settings =
       ; allow_uninitialized_decls= true
       ; optimize_ad_levels= false
       ; preserve_stability= false
-      ; optimize_soa= true }
+      ; optimize_soa= true
+      ; optimize_opencl= false }
   | Oexperimental -> all_optimizations
 
 let optimization_suite ?(settings = all_optimizations) mir =
@@ -1349,6 +1409,7 @@ let optimization_suite ?(settings = all_optimizations) mir =
       (* Book: Machine idioms and instruction combining *)
     ; (optimize_ad_levels, settings.optimize_ad_levels)
     ; (optimize_soa, settings.optimize_soa)
+    ; (optimize_opencl, settings.optimize_opencl)
       (*Remove decls immediately assigned to*)
     ; (allow_uninitialized_decls, settings.allow_uninitialized_decls)
       (* Book: Machine idioms and instruction combining *)
diff --git a/src/analysis_and_optimization/Optimize.mli b/src/analysis_and_optimization/Optimize.mli
index 2885ce9b4..db1693eee 100644
--- a/src/analysis_and_optimization/Optimize.mli
+++ b/src/analysis_and_optimization/Optimize.mli
@@ -79,7 +79,8 @@ type optimization_settings =
   ; lazy_code_motion: bool
   ; optimize_ad_levels: bool
   ; preserve_stability: bool
-  ; optimize_soa: bool }
+  ; optimize_soa: bool
+  ; optimize_opencl: bool }
 
 val all_optimizations : optimization_settings
 val no_optimizations : optimization_settings
diff --git a/src/frontend/Ast.ml b/src/frontend/Ast.ml
index 3cc8be62d..5b4ab3a3f 100644
--- a/src/frontend/Ast.ml
+++ b/src/frontend/Ast.ml
@@ -329,14 +329,14 @@ let type_of_arguments :
 
 let get_loc_dt (t : untyped_expression SizedType.t) =
   match t with
-  | SInt | SReal | SComplex | STuple _ -> None
+  | SInt _ | SReal _ | SComplex | STuple _ -> None
   | SVector (_, e)
    |SRowVector (_, e)
    |SMatrix (_, e, _)
    |SComplexVector e
    |SComplexRowVector e
    |SComplexMatrix (e, _)
-   |SArray (_, e) ->
+   |SArray (_, _, e) ->
       Some e.emeta.loc.begin_loc
 
 let get_loc_tf (t : untyped_expression Transformation.t) =
diff --git a/src/frontend/Ast_to_Mir.ml b/src/frontend/Ast_to_Mir.ml
index 06b9ffb6c..3e68b1f32 100644
--- a/src/frontend/Ast_to_Mir.ml
+++ b/src/frontend/Ast_to_Mir.ml
@@ -296,20 +296,21 @@ let extract_transform_args var = function
 let rec param_size transform sizedtype =
   let rec shrink_eigen f st =
     match st with
-    | SizedType.SArray (t, d) -> SizedType.SArray (shrink_eigen f t, d)
+    | SizedType.SArray (mem, t, d) -> SizedType.SArray (mem, shrink_eigen f t, d)
     | SVector (mem_pattern, d) | SMatrix (mem_pattern, d, _) ->
         SVector (mem_pattern, f d)
-    | SInt | SReal | SComplex | SRowVector _ | STuple _ | SComplexRowVector _
-     |SComplexVector _ | SComplexMatrix _ ->
+    | SInt _ | SReal _ | SComplex | SRowVector _ | STuple _
+     |SComplexRowVector _ | SComplexVector _ | SComplexMatrix _ ->
         Common.FatalError.fatal_error_msg
           [%message
             "Expecting SVector or SMatrix, got " (st : Expr.Typed.t SizedType.t)]
   in
   let rec shrink_eigen_mat f st =
     match st with
-    | SizedType.SArray (t, d) -> SizedType.SArray (shrink_eigen_mat f t, d)
+    | SizedType.SArray (mem, t, d) ->
+        SizedType.SArray (mem, shrink_eigen_mat f t, d)
     | SMatrix (mem_pattern, d1, d2) -> SVector (mem_pattern, f d1 d2)
-    | SInt | SReal | SComplex | SRowVector _ | SVector _ | STuple _
+    | SInt _ | SReal _ | SComplex | SRowVector _ | SVector _ | STuple _
      |SComplexRowVector _ | SComplexVector _ | SComplexMatrix _ ->
         Common.FatalError.fatal_error_msg
           [%message "Expecting SMatrix, got " (st : Expr.Typed.t SizedType.t)]
@@ -397,7 +398,7 @@ let check_sizedtype name st =
               ; str (Fmt.str "%a" Pretty_printing.pp_typed_expression x); n ]
             n.meta.loc ] in
   let rec sizedtype = function
-    | SizedType.(SInt | SReal | SComplex) as t -> ([], t)
+    | SizedType.(SInt _ | SReal _ | SComplex) as t -> ([], t)
     | SVector (mem_pattern, s) ->
         let e = trans_expr s in
         (check s e, SizedType.SVector (mem_pattern, e))
@@ -418,10 +419,10 @@ let check_sizedtype name st =
         let er = trans_expr r in
         let ec = trans_expr c in
         (check r er @ check c ec, SizedType.SComplexMatrix (er, ec))
-    | SArray (t, s) ->
+    | SArray (mem, t, s) ->
         let e = trans_expr s in
         let ll, t = sizedtype t in
-        (check s e @ ll, SizedType.SArray (t, e))
+        (check s e @ ll, SizedType.SArray (mem, t, e))
     | STuple subtypes ->
         let checks, subtypes = List.unzip (List.map ~f:sizedtype subtypes) in
         (List.concat checks, STuple subtypes) in
@@ -680,7 +681,7 @@ let rec trans_sizedtype_decl declc tr name st =
         let decl =
           { Stmt.Fixed.pattern=
               Decl
-                { decl_type= Sized SInt
+                { decl_type= Sized (SInt AoS)
                 ; decl_id
                 ; decl_adtype= DataOnly
                 ; initialize= true }
@@ -699,7 +700,7 @@ let rec trans_sizedtype_decl declc tr name st =
                   ; loc= s.emeta.loc } } in
         ([decl; assign; check fn s var], var) in
   let rec go n = function
-    | SizedType.(SInt | SReal | SComplex) as t -> ([], t)
+    | SizedType.(SInt _ | SReal _ | SComplex) as t -> ([], t)
     | SVector (mem_pattern, s) ->
         let fn =
           match (declc.transform_action, tr) with
@@ -739,10 +740,10 @@ let rec trans_sizedtype_decl declc tr name st =
         let l1, r = grab_size FnValidateSize n r in
         let l2, c = grab_size FnValidateSize (n + 1) c in
         (l1 @ l2, SizedType.SComplexMatrix (r, c))
-    | SArray (t, s) ->
+    | SArray (mem, t, s) ->
         let l, s = grab_size FnValidateSize n s in
         let ll, t = go (n + 1) t in
-        (l @ ll, SizedType.SArray (t, s))
+        (l @ ll, SizedType.SArray (mem, t, s))
     | STuple subtypes ->
         let former_array_indices =
           String.concat (List.init (n - 1) ~f:(fun _ -> "[]")) in
diff --git a/src/frontend/Pretty_printing.ml b/src/frontend/Pretty_printing.ml
index 4a8e31479..5b8b62410 100644
--- a/src/frontend/Pretty_printing.ml
+++ b/src/frontend/Pretty_printing.ml
@@ -335,7 +335,7 @@ let rec pp_transformed_type ppf (st, trans) =
           const (fun ppf -> pf ppf "[%a]" pp_expression) e
       | SMatrix (_, e1, e2) | SComplexMatrix (e1, e2) ->
           const (fun ppf -> pf ppf "[%a, %a]" pp_expression e1 pp_expression) e2
-      | SArray _ | SInt | SReal | SComplex | STuple _ -> nop in
+      | SArray _ | SInt _ | SReal _ | SComplex | STuple _ -> nop in
     let cov_sizes_fmt =
       match st with
       | SMatrix (_, e1, e2) ->
diff --git a/src/frontend/Typechecker.ml b/src/frontend/Typechecker.ml
index 60e245195..543a48a36 100644
--- a/src/frontend/Typechecker.ml
+++ b/src/frontend/Typechecker.ml
@@ -1412,7 +1412,7 @@ and verify_valid_transformation_for_type loc is_global sized_ty trans =
     | Upper e -> is_real e
     | LowerUpper (e1, e2) -> is_real e1 || is_real e2
     | _ -> false in
-  if is_global && sized_ty = SizedType.SInt && is_real_transformation then
+  if is_global && sized_ty = SizedType.SInt AoS && is_real_transformation then
     Semantic_error.non_int_bounds loc |> error ;
   let is_transformation =
     match trans with Transformation.Identity -> false | _ -> true in
@@ -1429,8 +1429,8 @@ and verify_transformed_param_ty loc cf is_global unsized_ty =
 and check_sizedtype cf tenv sizedty =
   let check e msg = check_expression_of_int_type cf tenv e msg in
   match sizedty with
-  | SizedType.SInt -> SizedType.SInt
-  | SReal -> SReal
+  | SizedType.SInt mem -> SizedType.SInt mem
+  | SReal mem -> SReal mem
   | SComplex -> SComplex
   | SVector (mem_pattern, e) ->
       let te = check e "Vector sizes" in
@@ -1452,10 +1452,10 @@ and check_sizedtype cf tenv sizedty =
       let te1 = check e1 "Complex matrix row size" in
       let te2 = check e2 "Complex matrix column size" in
       SComplexMatrix (te1, te2)
-  | SArray (st, e) ->
+  | SArray (mem, st, e) ->
       let tst = check_sizedtype cf tenv st in
       let te = check e "Array sizes" in
-      SArray (tst, te)
+      SArray (mem, tst, te)
   | STuple subtypes ->
       let typed_subtypes = List.map ~f:(check_sizedtype cf tenv) subtypes in
       STuple typed_subtypes
diff --git a/src/frontend/parser.mly b/src/frontend/parser.mly
index 57bbdcf75..244eea4e6 100644
--- a/src/frontend/parser.mly
+++ b/src/frontend/parser.mly
@@ -10,7 +10,7 @@ open Preprocessor
 (* Takes a sized_basic_type and a list of sizes and repeatedly applies then
    SArray constructor, taking sizes off the list *)
 let reducearray (sbt, l) =
-  List.fold_right l ~f:(fun z y -> SizedType.SArray (y, z)) ~init:sbt
+  List.fold_right l ~f:(fun z y -> SizedType.SArray (Mem_pattern.AoS, y, z)) ~init:sbt
 
 let build_id id loc =
   grammar_logger ("identifier " ^ id) ;
@@ -454,9 +454,9 @@ top_var_decl_no_assign:
 
 sized_basic_type:
   | INT
-    { grammar_logger "INT_var_type" ; (SizedType.SInt, Identity) }
+    { grammar_logger "INT_var_type" ; (SizedType.SInt AoS, Identity) }
   | REAL
-    { grammar_logger "REAL_var_type" ; (SizedType.SReal, Identity) }
+    { grammar_logger "REAL_var_type" ; (SizedType.SReal AoS, Identity) }
   | COMPLEX
     { grammar_logger "COMPLEX_var_type" ; (SizedType.SComplex, Identity) }
   | VECTOR LBRACK e=expression RBRACK
@@ -474,9 +474,9 @@ sized_basic_type:
 
 top_var_type:
   | INT r=range_constraint
-    { grammar_logger "INT_top_var_type" ; (SInt, r) }
+    { grammar_logger "INT_top_var_type" ; (SInt AoS, r) }
   | REAL c=type_constraint
-    { grammar_logger "REAL_top_var_type" ; (SReal, c) }
+    { grammar_logger "REAL_top_var_type" ; (SReal AoS, c) }
   | COMPLEX c=type_constraint
     { grammar_logger "COMPLEX_var_type" ; (SComplex, c) }
   | VECTOR c=type_constraint LBRACK e=expression RBRACK
diff --git a/src/middle/Expr.ml b/src/middle/Expr.ml
index f9a9967f5..b4bb1187c 100644
--- a/src/middle/Expr.ml
+++ b/src/middle/Expr.ml
@@ -97,9 +97,10 @@ module Helpers = struct
   let zero = int 0
   let one = int 1
 
-  let unary_op op e =
+  let unary_op ?(mem_pattern = Mem_pattern.SoA) op e =
     { Fixed.meta= Typed.Meta.empty
-    ; pattern= FunApp (StanLib (Operator.to_string op, FnPlain, AoS), [e]) }
+    ; pattern=
+        FunApp (StanLib (Operator.to_string op, FnPlain, mem_pattern), [e]) }
 
   let binop e1 op e2 =
     { Fixed.meta= Typed.Meta.empty
diff --git a/src/middle/Expr.mli b/src/middle/Expr.mli
index 2791a33ae..01ac6d54f 100644
--- a/src/middle/Expr.mli
+++ b/src/middle/Expr.mli
@@ -52,7 +52,7 @@ module Helpers : sig
   val variable : string -> Typed.t
   val zero : Typed.t
   val one : Typed.t
-  val unary_op : Operator.t -> Typed.t -> Typed.t
+  val unary_op : ?mem_pattern:Mem_pattern.t -> Operator.t -> Typed.t -> Typed.t
   val binop : Typed.t -> Operator.t -> Typed.t -> Typed.t
   val binop_list : Typed.t list -> Operator.t -> default:Typed.t -> Typed.t
   val row_vector : float list -> Typed.t
diff --git a/src/middle/Index.ml b/src/middle/Index.ml
index c082effd2..8441900d5 100644
--- a/src/middle/Index.ml
+++ b/src/middle/Index.ml
@@ -43,6 +43,13 @@ let apply ~default ~merge op (ind : 'a t) =
   | Between (expr_top, expr_bottom) -> merge (op expr_top) (op expr_bottom)
   | MultiIndex exprs -> op exprs
 
+let map_expr ~f = function
+  | All -> All
+  | Single ind_expr -> Single (f ind_expr)
+  | Upfrom ind_expr -> Upfrom ind_expr
+  | Between (expr_top, expr_bottom) -> Between (f expr_top, f expr_bottom)
+  | MultiIndex exprs -> MultiIndex (f exprs)
+
 let folder (acc : string Set.Poly.t) op (ind : 'a t) : string Set.Poly.t =
   match ind with
   | All -> acc
diff --git a/src/middle/Mem_pattern.ml b/src/middle/Mem_pattern.ml
index fc25eda3d..84e007daa 100644
--- a/src/middle/Mem_pattern.ml
+++ b/src/middle/Mem_pattern.ml
@@ -1,5 +1,4 @@
 open Core_kernel
-open Core_kernel.Poly
 
 (**
   * This type represents whether or not an autodiff type can be represented
@@ -11,13 +10,18 @@ open Core_kernel.Poly
   * (fyi a var in the C++ code is an alias for var_value<double>)
   *
  **)
-type t = AoS | SoA [@@deriving sexp, compare, map, hash, fold, equal]
+type t = AoS | SoA | OpenCL [@@deriving sexp, compare, map, hash, fold, equal]
 
 let pp ppf = function
   | AoS -> Fmt.string ppf "AoS"
   | SoA -> Fmt.string ppf "SoA"
+  | OpenCL -> Fmt.string ppf "OpenCL"
+
+let is_soa mem = match mem with SoA -> true | _ -> false
+let is_aos mem = match mem with AoS -> true | _ -> false
+let is_opencl mem = match mem with OpenCL -> true | _ -> false
 
 let lub_mem_pat lst =
-  let find_soa mem_pat = mem_pat = SoA in
+  let find_soa mem_pat = match mem_pat with SoA -> true | _ -> false in
   let any_soa = List.exists ~f:find_soa lst in
   match any_soa with true -> SoA | false -> AoS
diff --git a/src/middle/SizedType.ml b/src/middle/SizedType.ml
index 60bf8baa4..ae221d164 100644
--- a/src/middle/SizedType.ml
+++ b/src/middle/SizedType.ml
@@ -3,8 +3,8 @@
 open Core_kernel
 
 type 'a t =
-  | SInt
-  | SReal
+  | SInt of Mem_pattern.t
+  | SReal of Mem_pattern.t
   | SComplex
   | SVector of Mem_pattern.t * 'a
   | SRowVector of Mem_pattern.t * 'a
@@ -12,13 +12,13 @@ type 'a t =
   | SComplexVector of 'a
   | SComplexRowVector of 'a
   | SComplexMatrix of 'a * 'a
-  | SArray of 'a t * 'a
+  | SArray of Mem_pattern.t * 'a t * 'a
   | STuple of 'a t list
 [@@deriving sexp, compare, map, hash, fold]
 
 let rec pp pp_e ppf = function
-  | SInt -> Fmt.string ppf "int"
-  | SReal -> Fmt.string ppf "real"
+  | SInt _ -> Fmt.string ppf "int"
+  | SReal _ -> Fmt.string ppf "real"
   | SComplex -> Fmt.string ppf "complex"
   | SVector (_, expr) -> Fmt.pf ppf "vector%a" (Fmt.brackets pp_e) expr
   | SRowVector (_, expr) -> Fmt.pf ppf "row_vector%a" (Fmt.brackets pp_e) expr
@@ -34,7 +34,7 @@ let rec pp pp_e ppf = function
       Fmt.pf ppf "complex_matrix%a"
         Fmt.(pair ~sep:comma pp_e pp_e |> brackets)
         (d1_expr, d2_expr)
-  | SArray (st, expr) ->
+  | SArray (_, st, expr) ->
       Fmt.pf ppf "array%a"
         Fmt.(pair ~sep:comma (fun ppf st -> pp pp_e ppf st) pp_e |> brackets)
         (st, expr)
@@ -42,8 +42,8 @@ let rec pp pp_e ppf = function
       Fmt.pf ppf "tuple(@[%a@])" Fmt.(list ~sep:comma (pp pp_e)) subtypes
 
 let rec to_unsized = function
-  | SInt -> UnsizedType.UInt
-  | SReal -> UReal
+  | SInt _ -> UnsizedType.UInt
+  | SReal _ -> UReal
   | SComplex -> UComplex
   | SVector _ -> UVector
   | SRowVector _ -> URowVector
@@ -51,7 +51,7 @@ let rec to_unsized = function
   | SComplexVector _ -> UComplexVector
   | SComplexRowVector _ -> UComplexRowVector
   | SComplexMatrix _ -> UComplexMatrix
-  | SArray (t, _) -> UArray (to_unsized t)
+  | SArray (_, t, _) -> UArray (to_unsized t)
   | STuple subtypes -> UTuple (List.map ~f:to_unsized subtypes)
 
 (**
@@ -65,13 +65,13 @@ let rec to_unsized = function
 let rec get_dims_io st =
   let two = Expr.Helpers.int 2 in
   match st with
-  | SInt | SReal -> []
+  | SInt _ | SReal _ -> []
   | SComplex -> [two]
   | SVector (_, d) | SRowVector (_, d) -> [d]
   | SMatrix (_, dim1, dim2) -> [dim1; dim2]
   | SComplexVector d | SComplexRowVector d -> [d; two]
   | SComplexMatrix (dim1, dim2) -> [dim1; dim2; two]
-  | SArray (t, dim) -> dim :: get_dims_io t
+  | SArray (_, t, dim) -> dim :: get_dims_io t
   | STuple _ ->
       Common.FatalError.fatal_error_msg
         [%message
@@ -81,7 +81,7 @@ let rec get_dims_io st =
 let rec io_size st =
   let two = Expr.Helpers.int 2 in
   match st with
-  | SInt | SReal -> Expr.Helpers.one
+  | SInt _ | SReal _ -> Expr.Helpers.one
   | STuple subtypes ->
       Expr.Helpers.binop_list
         (List.map ~f:io_size subtypes)
@@ -94,8 +94,8 @@ let rec io_size st =
   | SComplexMatrix (dim1, dim2) ->
       Expr.Helpers.binop dim1 Operator.Times
         (Expr.Helpers.binop dim2 Operator.Times two)
-  | SArray ((SReal | SInt), dim) -> dim
-  | SArray (t, dim) -> Expr.Helpers.binop dim Operator.Times (io_size t)
+  | SArray (_, (SReal _ | SInt _), dim) -> dim
+  | SArray (_, t, dim) -> Expr.Helpers.binop dim Operator.Times (io_size t)
 
 (**
  Get the dimensions of an object.
@@ -104,22 +104,22 @@ let rec io_size st =
 *)
 let rec get_dims st =
   match st with
-  | STuple _ | SInt | SReal | SComplex -> []
+  | STuple _ | SInt _ | SReal _ | SComplex -> []
   | SMatrix (_, d1, d2) | SComplexMatrix (d1, d2) -> [d1; d2]
   | SRowVector (_, dim)
    |SVector (_, dim)
    |SComplexRowVector dim
    |SComplexVector dim ->
       [dim]
-  | SArray (t, dim) -> dim :: get_dims t
+  | SArray (_, t, dim) -> dim :: get_dims t
 
 (**
  * Check whether a SizedType holds indexable SizedTypes.
  *)
 let is_recursive_container st =
   match st with
-  | SInt | SReal | SComplex | SVector _ | SRowVector _ | SMatrix _
-   |SArray ((SInt | SReal), _)
+  | SInt _ | SReal _ | SComplex | SVector _ | SRowVector _ | SMatrix _
+   |SArray (_, (SInt _ | SReal _), _)
    |SComplexMatrix _ | SComplexRowVector _ | SComplexVector _ ->
       false
   | SArray _ -> true
@@ -128,10 +128,10 @@ let is_recursive_container st =
 (** Return a type's array dimensions and the type inside the (possibly nested) array *)
 let rec get_array_dims st =
   match st with
-  | SInt | SReal | SComplex | STuple _ | SVector _ | SRowVector _ | SMatrix _
-   |SComplexMatrix _ | SComplexVector _ | SComplexRowVector _ ->
+  | SInt _ | SReal _ | SComplex | STuple _ | SVector _ | SRowVector _
+   |SMatrix _ | SComplexMatrix _ | SComplexVector _ | SComplexRowVector _ ->
       (st, [])
-  | SArray (st, dim) ->
+  | SArray (_, st, dim) ->
       let st', dims = get_array_dims st in
       (st', dim :: dims)
 
@@ -141,21 +141,21 @@ let rec get_array_dims st =
   *)
 let rec get_scalar_and_dims st =
   match st with
-  | SInt | SReal | SComplex | STuple _ -> (st, [])
+  | SInt _ | SReal _ | SComplex | STuple _ -> (st, [])
   | SVector (_, d) | SRowVector (_, d) | SComplexVector d | SComplexRowVector d
     ->
       (st, [d])
   | SMatrix (_, d1, d2) | SComplexMatrix (d1, d2) -> (st, [d1; d2])
-  | SArray (st, dim) ->
+  | SArray (_, st, dim) ->
       let st', dims = get_scalar_and_dims st in
       (st', dim :: dims)
 
 let rec internal_scalar st =
   match st with
-  | SInt | SReal | SComplex | STuple _ -> st
-  | SVector _ | SRowVector _ | SMatrix _ -> SReal
+  | SInt _ | SReal _ | SComplex | STuple _ -> st
+  | SVector (mem, _) | SRowVector (mem, _) | SMatrix (mem, _, _) -> SReal mem
   | SComplexVector _ | SComplexRowVector _ | SComplexMatrix _ -> SComplex
-  | SArray (t, _) -> internal_scalar t
+  | SArray (_, t, _) -> internal_scalar t
 
 let%expect_test "dims" =
   let open Fmt in
@@ -165,7 +165,8 @@ let%expect_test "dims" =
          match pattern with Expr.Fixed.Pattern.Lit (_, x) -> x | _ -> "fail" )
        (get_dims_io
           (SArray
-             ( SMatrix
+             ( Mem_pattern.AoS
+             , SMatrix
                  (Mem_pattern.AoS, Expr.Helpers.str "x", Expr.Helpers.str "y")
              , Expr.Helpers.str "z" ) ) ) )
   |> print_endline ;
@@ -174,7 +175,7 @@ let%expect_test "dims" =
 let rec contains_tuple st =
   match st with
   | STuple _ -> true
-  | SArray (st, _) -> contains_tuple st
+  | SArray (_, st, _) -> contains_tuple st
   | _ -> false
 
 let is_complex_type st = UnsizedType.is_complex_type (to_unsized st)
@@ -184,35 +185,44 @@ let is_complex_type st = UnsizedType.is_complex_type (to_unsized st)
  *)
 let rec get_mem_pattern st =
   match st with
-  | SInt | SReal | SComplex | SComplexVector _ | SComplexRowVector _
-   |SComplexMatrix _ | STuple _ ->
+  | SComplex | SComplexVector _ | SComplexRowVector _ | SComplexMatrix _
+   |STuple _ ->
       Mem_pattern.AoS
-  | SVector (mem, _) | SRowVector (mem, _) | SMatrix (mem, _, _) -> mem
-  | SArray (t, _) -> get_mem_pattern t
+  | SInt mem
+   |SReal mem
+   |SVector (mem, _)
+   |SRowVector (mem, _)
+   |SMatrix (mem, _, _) ->
+      mem
+  (* TODO: Sort this out *)
+  | SArray (_, t, _) -> get_mem_pattern t
 
-(*Given a sizedtype, demote it's mem pattern from SoA to AoS*)
+(*Given a sizedtype, demote it's mem pattern from SoA or OpenCL to AoS*)
 let rec demote_sizedtype_mem st =
   match st with
-  | ( SInt | SReal | SComplex
+  | ( SInt _ | SReal _ | SComplex
     | SVector (AoS, _)
     | SRowVector (AoS, _)
     | SMatrix (AoS, _, _)
     | SComplexVector _ | SComplexRowVector _
     | SComplexMatrix (_, _) ) as ret ->
       ret
-  | SArray (inner_type, dim) -> SArray (demote_sizedtype_mem inner_type, dim)
-  | SVector (SoA, dim) -> SVector (AoS, dim)
-  | SRowVector (SoA, dim) -> SRowVector (AoS, dim)
-  | SMatrix (SoA, dim1, dim2) -> SMatrix (AoS, dim1, dim2)
+  | SArray (AoS, t, dim) -> SArray (AoS, demote_sizedtype_mem t, dim)
+  | SArray ((SoA | OpenCL), inner_type, dim) ->
+      SArray (AoS, demote_sizedtype_mem inner_type, dim)
+  | SVector ((SoA | OpenCL), dim) -> SVector (AoS, dim)
+  | SRowVector ((SoA | OpenCL), dim) -> SRowVector (AoS, dim)
+  | SMatrix ((SoA | OpenCL), dim1, dim2) -> SMatrix (AoS, dim1, dim2)
   | STuple subtypes -> STuple (List.map ~f:demote_sizedtype_mem subtypes)
 
-(*Given a sizedtype, promote it's mem pattern from AoS to SoA*)
+(*Given a sizedtype, promote it's mem pattern from AoS to SoA *)
 let rec promote_sizedtype_mem st =
   match st with
   | SVector (AoS, dim) -> SVector (SoA, dim)
   | SRowVector (AoS, dim) -> SRowVector (SoA, dim)
   | SMatrix (AoS, dim1, dim2) -> SMatrix (SoA, dim1, dim2)
-  | SArray (inner_type, dim) -> SArray (promote_sizedtype_mem inner_type, dim)
+  | SArray (AoS, inner_type, dim) ->
+      SArray (SoA, promote_sizedtype_mem inner_type, dim)
   | _ -> st
 
 (*Given a mem_pattern and SizedType, modify the SizedType to AoS or SoA*)
@@ -220,20 +230,42 @@ let modify_sizedtype_mem (mem_pattern : Mem_pattern.t) st =
   match mem_pattern with
   | AoS -> demote_sizedtype_mem st
   | SoA -> promote_sizedtype_mem st
+  | OpenCL -> promote_sizedtype_mem st
+
+let rec promote_mem (mem_pattern : Mem_pattern.t) st =
+  match st with
+  | SInt _ -> SInt mem_pattern
+  | SReal _ -> SReal mem_pattern
+  | SVector (_, dim) -> SVector (mem_pattern, dim)
+  | SRowVector (_, dim) -> SRowVector (mem_pattern, dim)
+  | SMatrix (_, dim1, dim2) -> SMatrix (mem_pattern, dim1, dim2)
+  | SArray (_, inner_type, dim) ->
+      SArray (mem_pattern, promote_mem mem_pattern inner_type, dim)
+  | _ -> st
 
 let rec has_mem_pattern = function
-  | SInt | SReal | SComplex | SComplexVector _ | SComplexRowVector _
-   |SComplexMatrix _ ->
+  | SComplex | SComplexVector _ | SComplexRowVector _ | SComplexMatrix _ ->
       false
-  | SVector _ | SRowVector _ | SMatrix _ -> true
-  | SArray (t, _) -> has_mem_pattern t
+  | SInt _ | SReal _ | SVector _ | SRowVector _ | SMatrix _ -> true
+  | SArray _ -> true
   | STuple subtypes -> List.exists ~f:has_mem_pattern subtypes
 
+let is_eigen_type st =
+  match st with
+  | (SVector (mem, _) | SRowVector (mem, _) | SMatrix (mem, _, _))
+    when Mem_pattern.is_opencl mem ->
+      false
+  | SVector _ | SRowVector _ | SMatrix _ | SComplexRowVector _
+   |SComplexVector _ | SComplexMatrix _ ->
+      true
+  | _ -> false
+
 (** The inverse of [get_array_dims]
 *)
 let build_sarray dims st =
   let rec loop dims st =
-    match dims with [] -> st | d :: dims -> loop dims (SArray (st, d)) in
+    match dims with [] -> st | d :: dims -> loop dims (SArray (AoS, st, d))
+  in
   loop (List.rev dims) st
 
 let flatten_tuple_io st =
@@ -248,7 +280,9 @@ let flatten_tuple_io st =
 
 let%expect_test "dims" =
   let st : Expr.Typed.t t =
-    SArray (SArray (SReal, Expr.Helpers.variable "N"), Expr.Helpers.one) in
+    SArray
+      (AoS, SArray (AoS, SReal SoA, Expr.Helpers.variable "N"), Expr.Helpers.one)
+  in
   let sclr, dims = get_array_dims st in
   let st2 = build_sarray dims sclr in
   let open Fmt in
diff --git a/src/middle/Stan_math_signatures.ml b/src/middle/Stan_math_signatures.ml
index 23e4f972b..fa30a8453 100644
--- a/src/middle/Stan_math_signatures.ml
+++ b/src/middle/Stan_math_signatures.ml
@@ -212,50 +212,58 @@ let mk_declarative_sig (fnkinds, name, args, mem_pattern) =
 
 let full_lpdf = [Lpdf; Rng; Ccdf; Cdf]
 let full_lpmf = [Lpmf; Rng; Ccdf; Cdf]
+let less_lpf = [Rng; Ccdf; Cdf]
+let less_lpf_depr = less_lpf @ [Log]
 let full_lpdf_depr = full_lpdf @ [Log]
 let full_lpmf_depr = full_lpmf @ [Log]
 
 let distributions =
-  [ ( full_lpmf_depr
-    , "beta_binomial"
-    , [DVInt; DVInt; DVReal; DVReal]
-    , Mem_pattern.SoA ); (full_lpdf_depr, "beta", [DVReal; DVReal; DVReal], SoA)
-  ; ( [Lpdf; Ccdf; Cdf; Log]
-    , "beta_proportion"
-    , [DVReal; DVReal; DIntAndReals]
-    , SoA ); (full_lpmf_depr, "bernoulli", [DVInt; DVReal], SoA)
-  ; ([Lpmf; Rng; Log], "bernoulli_logit", [DVInt; DVReal], SoA)
-  ; ([Lpmf], "bernoulli_logit_glm", [DVInt; DMatrix; DReal; DVector], SoA)
-  ; (full_lpmf_depr, "binomial", [DVInt; DVInt; DVReal], SoA)
-  ; ([Lpmf; Log], "binomial_logit", [DVInt; DVInt; DVReal], SoA)
+  [ (full_lpmf_depr, "bernoulli", [DVInt; DVReal], Mem_pattern.SoA)
+  ; ([Lpmf], "bernoulli_logit_glm", [DVInt; DMatrix; DReal; DVector], OpenCL)
+  ; ([Lpmf], "bernoulli_logit", [DVInt; DVReal], OpenCL)
+  ; ([Rng; Log], "bernoulli_logit", [DVInt; DVReal], SoA)
+  ; (less_lpf_depr, "beta_binomial", [DVInt; DVInt; DVReal; DVReal], SoA)
+  ; ([Lpmf], "beta_binomial", [DVInt; DVInt; DVReal; DVReal], OpenCL)
+  ; (less_lpf_depr, "beta", [DVReal; DVReal; DVReal], OpenCL)
+  ; ([Lpdf], "beta", [DVReal; DVReal; DVReal], SoA)
+  ; (less_lpf_depr, "beta_proportion", [DVReal; DVReal; DIntAndReals], SoA)
+  ; ([Lpdf], "beta_proportion", [DVReal; DVReal; DIntAndReals], OpenCL)
+  ; ([Log], "binomial_logit", [DVInt; DVInt; DVReal], SoA)
+  ; ([Lpmf], "binomial_logit", [DVInt; DVInt; DVReal], OpenCL)
+  ; (less_lpf_depr, "binomial", [DVInt; DVInt; DVReal], SoA)
+  ; ([Lpmf], "binomial", [DVInt; DVInt; DVReal], OpenCL)
   ; ([Lpmf; Log], "categorical", [DVInt; DVector], AoS)
   ; ([Lpmf; Log], "categorical_logit", [DVInt; DVector], AoS)
-  ; ([Lpmf], "categorical_logit_glm", [DVInt; DMatrix; DVector; DMatrix], SoA)
-  ; (full_lpdf_depr, "cauchy", [DVReal; DVReal; DVReal], SoA)
-  ; (full_lpdf_depr, "chi_square", [DVReal; DVReal], SoA)
-  ; ([Lpdf; Log], "dirichlet", [DVectors; DVectors], SoA)
+  ; ([Lpmf], "categorical_logit_glm", [DVInt; DMatrix; DVector; DMatrix], OpenCL)
+  ; (full_lpdf_depr, "cauchy", [DVReal; DVReal; DVReal], OpenCL)
+  ; (less_lpf_depr, "chi_square", [DVReal; DVReal], SoA)
+  ; ([Lpdf], "chi_square", [DVReal; DVReal], OpenCL)
+  ; ([Lpdf; Log], "dirichlet", [DVectors; DVectors], OpenCL)
   ; (full_lpmf_depr, "discrete_range", [DVInt; DVInt; DVInt], SoA)
-  ; (full_lpdf_depr, "double_exponential", [DVReal; DVReal; DVReal], SoA)
-  ; (full_lpdf_depr, "exp_mod_normal", [DVReal; DVReal; DVReal; DVReal], SoA)
-  ; (full_lpdf_depr, "exponential", [DVReal; DVReal], SoA)
-  ; (full_lpdf_depr, "frechet", [DVReal; DVReal; DVReal], SoA)
-  ; (full_lpdf_depr, "gamma", [DVReal; DVReal; DVReal], SoA)
+  ; (full_lpdf_depr, "double_exponential", [DVReal; DVReal; DVReal], OpenCL)
+  ; (full_lpdf_depr, "exp_mod_normal", [DVReal; DVReal; DVReal; DVReal], OpenCL)
+  ; (full_lpdf_depr, "exponential", [DVReal; DVReal], OpenCL)
+  ; (full_lpdf_depr, "frechet", [DVReal; DVReal; DVReal], OpenCL)
+  ; (less_lpf_depr, "gamma", [DVReal; DVReal; DVReal], SoA)
+  ; ([Lpdf], "gamma", [DVReal; DVReal; DVReal], OpenCL)
   ; ( [Lpdf; Log]
     , "gaussian_dlm_obs"
     , [DMatrix; DMatrix; DMatrix; DMatrix; DMatrix; DVector; DMatrix]
-    , AoS ); (full_lpdf_depr, "gumbel", [DVReal; DVReal; DVReal], SoA)
+    , AoS ); (full_lpdf_depr, "gumbel", [DVReal; DVReal; DVReal], OpenCL)
   ; ([Rng], "hmm_latent", [DIntArray; DMatrix; DMatrix; DVector], AoS)
-  ; ([Lpmf; Rng; Log], "hypergeometric", [DInt; DInt; DInt; DInt], SoA)
-  ; (full_lpdf_depr, "inv_chi_square", [DVReal; DVReal], SoA)
-  ; (full_lpdf_depr, "inv_gamma", [DVReal; DVReal; DVReal], SoA)
+  ; ([Lpmf; Rng; Log], "hypergeometric", [DInt; DInt; DInt; DInt], OpenCL)
+  ; (less_lpf_depr, "inv_chi_square", [DVReal; DVReal], SoA)
+  ; ([Lpdf], "inv_chi_square", [DVReal; DVReal], OpenCL)
+  ; (less_lpf_depr, "inv_gamma", [DVReal; DVReal; DVReal], OpenCL)
+  ; ([Lpdf], "inv_gamma", [DVReal; DVReal; DVReal], SoA)
   ; ([Lpdf], "inv_wishart_cholesky", [DMatrix; DReal; DMatrix], SoA)
   ; ([Lpdf; Log], "inv_wishart", [DMatrix; DReal; DMatrix], SoA)
   ; ([Lpdf; Log], "lkj_corr", [DMatrix; DReal], AoS)
   ; ([Lpdf; Log], "lkj_corr_cholesky", [DMatrix; DReal], AoS)
   ; ([Lpdf; Log], "lkj_cov", [DMatrix; DVector; DVector; DReal], AoS)
-  ; (full_lpdf_depr, "logistic", [DVReal; DVReal; DVReal], SoA)
+  ; (full_lpdf_depr, "logistic", [DVReal; DVReal; DVReal], OpenCL)
   ; ([Lpdf; Rng; Cdf; Log], "loglogistic", [DVReal; DVReal; DVReal], SoA)
-  ; (full_lpdf_depr, "lognormal", [DVReal; DVReal; DVReal], SoA)
+  ; (full_lpdf_depr, "lognormal", [DVReal; DVReal; DVReal], OpenCL)
   ; ([Lpdf; Log], "multi_gp", [DMatrix; DMatrix; DVector], AoS)
   ; ([Lpdf; Log], "multi_gp_cholesky", [DMatrix; DMatrix; DVector], AoS)
   ; ([Lpmf; Log], "multinomial", [DIntArray; DVector], AoS)
@@ -267,33 +275,40 @@ let distributions =
   ; ( [Lpdf]
     , "multi_student_t_cholesky"
     , [DVectors; DReal; DVectors; DMatrix]
-    , SoA ); (full_lpmf_depr, "neg_binomial", [DVInt; DVReal; DVReal], SoA)
-  ; (full_lpmf_depr, "neg_binomial_2", [DVInt; DVReal; DVReal], SoA)
-  ; ([Lpmf; Rng; Log], "neg_binomial_2_log", [DVInt; DVReal; DVReal], SoA)
+    , OpenCL ); (less_lpf_depr, "neg_binomial", [DVInt; DVReal; DVReal], SoA)
+  ; ([Lpmf], "neg_binomial", [DVInt; DVReal; DVReal], OpenCL)
+  ; (less_lpf_depr, "neg_binomial_2", [DVInt; DVReal; DVReal], SoA)
+  ; ([Lpmf], "neg_binomial_2", [DVInt; DVReal; DVReal], OpenCL)
+  ; ([Lpmf; Rng; Log], "neg_binomial_2_log", [DVInt; DVReal; DVReal], OpenCL)
   ; ( [Lpmf]
     , "neg_binomial_2_log_glm"
     , [DVInt; DMatrix; DReal; DVector; DReal]
-    , SoA ); (full_lpdf_depr, "normal", [DVReal; DVReal; DVReal], SoA)
-  ; ([Lpdf], "normal_id_glm", [DVector; DMatrix; DReal; DVector; DReal], SoA)
-  ; ([Lpmf; Log], "ordered_logistic", [DInt; DReal; DVector], SoA)
-  ; ([Lpmf], "ordered_logistic_glm", [DVInt; DMatrix; DVector; DVector], SoA)
-  ; ([Lpmf; Log], "ordered_probit", [DInt; DReal; DVector], SoA)
-  ; (full_lpdf_depr, "pareto", [DVReal; DVReal; DVReal], SoA)
-  ; (full_lpdf_depr, "pareto_type_2", [DVReal; DVReal; DVReal; DVReal], SoA)
-  ; (full_lpmf_depr, "poisson", [DVInt; DVReal], SoA)
-  ; ([Lpmf; Rng; Log], "poisson_log", [DVInt; DVReal], SoA)
-  ; ([Lpmf], "poisson_log_glm", [DVInt; DMatrix; DReal; DVector], SoA)
-  ; (full_lpdf_depr, "rayleigh", [DVReal; DVReal], SoA)
-  ; (full_lpdf_depr, "scaled_inv_chi_square", [DVReal; DVReal; DVReal], SoA)
-  ; (full_lpdf_depr, "skew_normal", [DVReal; DVReal; DVReal; DVReal], SoA)
+    , OpenCL ); (full_lpdf_depr, "normal", [DVReal; DVReal; DVReal], OpenCL)
+  ; ([Lpdf], "normal_id_glm", [DVector; DMatrix; DReal; DVector; DReal], OpenCL)
+  ; ([Lpmf; Log], "ordered_logistic", [DInt; DReal; DVector], OpenCL)
+  ; ([Lpmf], "ordered_logistic_glm", [DVInt; DMatrix; DVector; DVector], OpenCL)
+  ; ([Lpmf; Log], "ordered_probit", [DInt; DReal; DVector], OpenCL)
+  ; (full_lpdf_depr, "pareto", [DVReal; DVReal; DVReal], OpenCL)
+  ; (full_lpdf_depr, "pareto_type_2", [DVReal; DVReal; DVReal; DVReal], OpenCL)
+  ; ([Lpmf], "poisson_log_glm", [DVInt; DMatrix; DReal; DVector], OpenCL)
+  ; ([Lpmf; Rng; Log], "poisson_log", [DVInt; DVReal], OpenCL)
+  ; (less_lpf_depr, "poisson", [DVInt; DVReal], SoA)
+  ; ([Lpmf], "poisson", [DVInt; DVReal], OpenCL)
+  ; (full_lpdf_depr, "rayleigh", [DVReal; DVReal], OpenCL)
+  ; (less_lpf_depr, "scaled_inv_chi_square", [DVReal; DVReal; DVReal], SoA)
+  ; ([Lpdf], "scaled_inv_chi_square", [DVReal; DVReal; DVReal], OpenCL)
   ; ( full_lpdf_depr
     , "skew_double_exponential"
     , [DVReal; DVReal; DVReal; DVReal]
-    , SoA ); (full_lpdf_depr, "student_t", [DVReal; DVReal; DVReal; DVReal], SoA)
-  ; (full_lpdf_depr, "std_normal", [DVReal], SoA)
-  ; (full_lpdf_depr, "uniform", [DVReal; DVReal; DVReal], SoA)
+    , OpenCL )
+  ; (less_lpf_depr, "skew_normal", [DVReal; DVReal; DVReal; DVReal], SoA)
+  ; ([Lpdf], "skew_normal", [DVReal; DVReal; DVReal; DVReal], OpenCL)
+  ; (full_lpdf_depr, "std_normal", [DVReal], OpenCL)
+  ; (less_lpf_depr, "student_t", [DVReal; DVReal; DVReal; DVReal], SoA)
+  ; ([Lpdf], "student_t", [DVReal; DVReal; DVReal; DVReal], OpenCL)
+  ; (full_lpdf_depr, "uniform", [DVReal; DVReal; DVReal], OpenCL)
   ; (full_lpdf_depr, "von_mises", [DVReal; DVReal; DVReal], SoA)
-  ; (full_lpdf_depr, "weibull", [DVReal; DVReal; DVReal], SoA)
+  ; (full_lpdf_depr, "weibull", [DVReal; DVReal; DVReal], OpenCL)
   ; ([Lpdf; Log], "wiener", [DVReal; DVReal; DVReal; DVReal; DVReal], SoA)
   ; ([Lpdf], "wishart_cholesky", [DMatrix; DReal; DMatrix], SoA)
   ; ([Lpdf; Log], "wishart", [DMatrix; DReal; DMatrix], SoA) ]
@@ -302,67 +317,67 @@ let basic_vectorized = UnaryVectorized IntsToReals
 
 let math_sigs =
   [ ([UnaryVectorized SameAsArg], "abs", [DDeepVectorized], Mem_pattern.SoA)
-  ; ([basic_vectorized], "acos", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "acosh", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "asin", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "asinh", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "atan", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "atanh", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "cbrt", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "ceil", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "cos", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "cosh", [DDeepVectorized], SoA)
+  ; ([basic_vectorized], "acos", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "acosh", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "asin", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "asinh", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "atan", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "atanh", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "cbrt", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "ceil", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "cos", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "cosh", [DDeepVectorized], OpenCL)
   ; ([UnaryVectorized SameAsArg], "conj", [DDeepComplexVectorized], AoS)
-  ; ([basic_vectorized], "digamma", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "erf", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "erfc", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "exp", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "exp2", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "expm1", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "fabs", [DDeepVectorized], SoA)
+  ; ([basic_vectorized], "digamma", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "erf", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "erfc", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "exp", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "exp2", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "expm1", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "fabs", [DDeepVectorized], OpenCL)
   ; ([UnaryVectorized ComplexToReals], "get_imag", [DDeepComplexVectorized], AoS)
   ; ([UnaryVectorized ComplexToReals], "get_real", [DDeepComplexVectorized], AoS)
   ; ([UnaryVectorized ComplexToReals], "abs", [DDeepComplexVectorized], AoS)
-  ; ([basic_vectorized], "floor", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "inv", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "inv_cloglog", [DDeepVectorized], SoA)
+  ; ([basic_vectorized], "floor", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "inv", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "inv_cloglog", [DDeepVectorized], OpenCL)
   ; ([basic_vectorized], "inv_erfc", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "inv_logit", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "inv_Phi", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "inv_sqrt", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "inv_square", [DDeepVectorized], SoA)
+  ; ([basic_vectorized], "inv_logit", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "inv_Phi", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "inv_sqrt", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "inv_square", [DDeepVectorized], OpenCL)
   ; ([basic_vectorized], "lambert_w0", [DDeepVectorized], SoA)
   ; ([basic_vectorized], "lambert_wm1", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "lgamma", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "log", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "log10", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "log1m", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "log1m_exp", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "log1m_inv_logit", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "log1p", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "log1p_exp", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "log2", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "log_inv_logit", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "logit", [DDeepVectorized], SoA)
-  ; ([UnaryVectorized SameAsArg], "minus", [DDeepVectorized], SoA)
-  ; ([UnaryVectorized SameAsArg], "minus", [DDeepComplexVectorized], SoA)
-  ; ([basic_vectorized], "Phi", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "Phi_approx", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "round", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "sin", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "sinh", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "sqrt", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "square", [DDeepVectorized], SoA)
+  ; ([basic_vectorized], "lgamma", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "log", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "log10", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "log1m", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "log1m_exp", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "log1m_inv_logit", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "log1p", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "log1p_exp", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "log2", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "log_inv_logit", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "logit", [DDeepVectorized], OpenCL)
+  ; ([UnaryVectorized SameAsArg], "minus", [DDeepVectorized], OpenCL)
+  ; ([UnaryVectorized SameAsArg], "minus", [DDeepComplexVectorized], OpenCL)
+  ; ([basic_vectorized], "Phi", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "Phi_approx", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "round", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "sin", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "sinh", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "sqrt", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "square", [DDeepVectorized], OpenCL)
     (* TODO: Eventually will want to move _qf to be part of the distribution list above *)
   ; ([basic_vectorized], "std_normal_qf", [DDeepVectorized], SoA)
     (* std_normal_qf is an alias for inv_Phi *)
   ; ([basic_vectorized], "std_normal_log_qf", [DDeepVectorized], SoA)
   ; ([basic_vectorized], "step", [DReal], SoA)
-  ; ([basic_vectorized], "tan", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "tanh", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "tgamma", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "trunc", [DDeepVectorized], SoA)
-  ; ([basic_vectorized], "trigamma", [DDeepVectorized], SoA) ]
+  ; ([basic_vectorized], "tan", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "tanh", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "tgamma", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "trunc", [DDeepVectorized], OpenCL)
+  ; ([basic_vectorized], "trigamma", [DDeepVectorized], OpenCL) ]
 
 let all_declarative_sigs = distributions @ math_sigs
 
@@ -437,9 +452,9 @@ let make_assignmentoperator_stan_math_signatures assop =
                    ( (assop = Operator.EltTimes || assop = Operator.EltDivide)
                    && UnsizedType.is_scalar_type rtype ) ->
            if rhs = UReal then
-             [ (UnsizedType.Void, [(ad1, lhs); (ad2, UInt)], Mem_pattern.SoA)
-             ; (Void, [(ad1, lhs); (ad2, UReal)], SoA) ]
-           else [(Void, [(ad1, lhs); (ad2, rhs)], SoA)]
+             [ (UnsizedType.Void, [(ad1, lhs); (ad2, UInt)], Mem_pattern.OpenCL)
+             ; (Void, [(ad1, lhs); (ad2, UReal)], OpenCL) ]
+           else [(Void, [(ad1, lhs); (ad2, rhs)], OpenCL)]
        | _ -> [] )
 
 let pp_math_sig ppf (rt, args, mem_pattern) =
@@ -756,26 +771,26 @@ let () =
   add_unqualified ("acos", ReturnType UComplex, [UComplex], AoS) ;
   add_unqualified ("acosh", ReturnType UComplex, [UComplex], AoS) ;
   List.iter
-    ~f:(fun x -> add_unqualified ("add", ReturnType x, [x; x], SoA))
+    ~f:(fun x -> add_unqualified ("add", ReturnType x, [x; x], OpenCL))
     bare_types ;
-  add_unqualified ("add", ReturnType UVector, [UVector; UReal], SoA) ;
-  add_unqualified ("add", ReturnType URowVector, [URowVector; UReal], SoA) ;
-  add_unqualified ("add", ReturnType UMatrix, [UMatrix; UReal], SoA) ;
-  add_unqualified ("add", ReturnType UVector, [UReal; UVector], SoA) ;
-  add_unqualified ("add", ReturnType URowVector, [UReal; URowVector], SoA) ;
-  add_unqualified ("add", ReturnType UMatrix, [UReal; UMatrix], SoA) ;
+  add_unqualified ("add", ReturnType UVector, [UVector; UReal], OpenCL) ;
+  add_unqualified ("add", ReturnType URowVector, [URowVector; UReal], OpenCL) ;
+  add_unqualified ("add", ReturnType UMatrix, [UMatrix; UReal], OpenCL) ;
+  add_unqualified ("add", ReturnType UVector, [UReal; UVector], OpenCL) ;
+  add_unqualified ("add", ReturnType URowVector, [UReal; URowVector], OpenCL) ;
+  add_unqualified ("add", ReturnType UMatrix, [UReal; UMatrix], OpenCL) ;
   add_unqualified
-    ("add", ReturnType UComplexVector, [UComplexVector; UComplex], SoA) ;
+    ("add", ReturnType UComplexVector, [UComplexVector; UComplex], OpenCL) ;
   add_unqualified
-    ("add", ReturnType UComplexRowVector, [UComplexRowVector; UComplex], SoA) ;
+    ("add", ReturnType UComplexRowVector, [UComplexRowVector; UComplex], OpenCL) ;
   add_unqualified
-    ("add", ReturnType UComplexMatrix, [UComplexMatrix; UComplex], SoA) ;
+    ("add", ReturnType UComplexMatrix, [UComplexMatrix; UComplex], OpenCL) ;
   add_unqualified
-    ("add", ReturnType UComplexVector, [UComplex; UComplexVector], SoA) ;
+    ("add", ReturnType UComplexVector, [UComplex; UComplexVector], OpenCL) ;
   add_unqualified
-    ("add", ReturnType UComplexRowVector, [UComplex; UComplexRowVector], SoA) ;
+    ("add", ReturnType UComplexRowVector, [UComplex; UComplexRowVector], OpenCL) ;
   add_unqualified
-    ("add", ReturnType UComplexMatrix, [UComplex; UComplexMatrix], SoA) ;
+    ("add", ReturnType UComplexMatrix, [UComplex; UComplexMatrix], OpenCL) ;
   add_unqualified ("add_diag", ReturnType UMatrix, [UMatrix; UReal], AoS) ;
   add_unqualified ("add_diag", ReturnType UMatrix, [UMatrix; UVector], AoS) ;
   add_unqualified ("add_diag", ReturnType UMatrix, [UMatrix; URowVector], AoS) ;
@@ -865,22 +880,22 @@ let () =
     ( "bernoulli_logit_glm_lpmf"
     , ReturnType UReal
     , [UArray UInt; UMatrix; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "bernoulli_logit_glm_lpmf"
     , ReturnType UReal
     , [UInt; UMatrix; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "bernoulli_logit_glm_lpmf"
     , ReturnType UReal
     , [UArray UInt; URowVector; UReal; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "bernoulli_logit_glm_lpmf"
     , ReturnType UReal
     , [UArray UInt; URowVector; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "bernoulli_logit_glm_rng"
     , ReturnType (UArray UInt)
@@ -893,7 +908,7 @@ let () =
     , AoS ) ;
   add_binary_vec_int_real "bessel_first_kind" SoA ;
   add_binary_vec_int_real "bessel_second_kind" SoA ;
-  add_binary_vec "beta" SoA ;
+  add_binary_vec "beta" OpenCL ;
   (* XXX For some reason beta_proportion_rng doesn't take ints as first arg *)
   for_vector_types (fun t ->
       for_all_vector_types (fun u ->
@@ -905,7 +920,7 @@ let () =
   add_binary_vec_int_real "binary_log_loss" AoS ;
   add_binary_vec "binomial_coefficient_log" AoS ;
   add_unqualified
-    ("block", ReturnType UMatrix, [UMatrix; UInt; UInt; UInt; UInt], SoA) ;
+    ("block", ReturnType UMatrix, [UMatrix; UInt; UInt; UInt; UInt], OpenCL) ;
   add_unqualified
     ( "block"
     , ReturnType UComplexMatrix
@@ -917,12 +932,12 @@ let () =
     ( "categorical_logit_glm_lpmf"
     , ReturnType UReal
     , [UArray UInt; URowVector; UVector; UMatrix]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "categorical_logit_glm_lpmf"
     , ReturnType UReal
     , [UInt; URowVector; UVector; UMatrix]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified ("append_col", ReturnType UMatrix, [UMatrix; UMatrix], AoS) ;
   add_unqualified ("append_col", ReturnType UMatrix, [UVector; UMatrix], AoS) ;
   add_unqualified ("append_col", ReturnType UMatrix, [UMatrix; UVector], AoS) ;
@@ -967,7 +982,7 @@ let () =
     , [UComplexRowVector; UComplex]
     , AoS ) ;
   add_unqualified ("chol2inv", ReturnType UMatrix, [UMatrix], AoS) ;
-  add_unqualified ("cholesky_decompose", ReturnType UMatrix, [UMatrix], SoA) ;
+  add_unqualified ("cholesky_decompose", ReturnType UMatrix, [UMatrix], OpenCL) ;
   add_binary_vec_int_int "choose" AoS ;
   add_unqualified ("col", ReturnType UVector, [UMatrix; UInt], AoS) ;
   add_unqualified ("col", ReturnType UComplexVector, [UComplexMatrix; UInt], SoA) ;
@@ -982,7 +997,7 @@ let () =
   add_unqualified
     ("columns_dot_product", ReturnType URowVector, [URowVector; URowVector], AoS) ;
   add_unqualified
-    ("columns_dot_product", ReturnType URowVector, [UMatrix; UMatrix], SoA) ;
+    ("columns_dot_product", ReturnType URowVector, [UMatrix; UMatrix], OpenCL) ;
   add_unqualified
     ( "columns_dot_product"
     , ReturnType UComplexRowVector
@@ -1077,8 +1092,8 @@ let () =
     ("cumulative_sum", ReturnType (UArray UInt), [UArray UInt], AoS) ;
   add_unqualified
     ("cumulative_sum", ReturnType (UArray UReal), [UArray UReal], AoS) ;
-  add_unqualified ("cumulative_sum", ReturnType UVector, [UVector], SoA) ;
-  add_unqualified ("cumulative_sum", ReturnType URowVector, [URowVector], SoA) ;
+  add_unqualified ("cumulative_sum", ReturnType UVector, [UVector], OpenCL) ;
+  add_unqualified ("cumulative_sum", ReturnType URowVector, [URowVector], OpenCL) ;
   add_unqualified
     ("cumulative_sum", ReturnType (UArray UComplex), [UArray UComplex], AoS) ;
   add_unqualified
@@ -1090,9 +1105,9 @@ let () =
   add_unqualified
     ("diag_matrix", ReturnType UComplexMatrix, [UComplexVector], AoS) ;
   add_unqualified
-    ("diag_post_multiply", ReturnType UMatrix, [UMatrix; UVector], SoA) ;
+    ("diag_post_multiply", ReturnType UMatrix, [UMatrix; UVector], OpenCL) ;
   add_unqualified
-    ("diag_post_multiply", ReturnType UMatrix, [UMatrix; URowVector], SoA) ;
+    ("diag_post_multiply", ReturnType UMatrix, [UMatrix; URowVector], OpenCL) ;
   add_unqualified
     ( "diag_post_multiply"
     , ReturnType UComplexMatrix
@@ -1104,9 +1119,9 @@ let () =
     , [UComplexMatrix; UComplexRowVector]
     , AoS ) ;
   add_unqualified
-    ("diag_pre_multiply", ReturnType UMatrix, [UVector; UMatrix], SoA) ;
+    ("diag_pre_multiply", ReturnType UMatrix, [UVector; UMatrix], OpenCL) ;
   add_unqualified
-    ("diag_pre_multiply", ReturnType UMatrix, [URowVector; UMatrix], SoA) ;
+    ("diag_pre_multiply", ReturnType UMatrix, [URowVector; UMatrix], OpenCL) ;
   add_unqualified
     ( "diag_pre_multiply"
     , ReturnType UComplexMatrix
@@ -1117,8 +1132,9 @@ let () =
     , ReturnType UComplexMatrix
     , [UComplexRowVector; UComplexMatrix]
     , AoS ) ;
-  add_unqualified ("diagonal", ReturnType UVector, [UMatrix], SoA) ;
-  add_unqualified ("diagonal", ReturnType UComplexVector, [UComplexMatrix], SoA) ;
+  add_unqualified ("diagonal", ReturnType UVector, [UMatrix], OpenCL) ;
+  add_unqualified
+    ("diagonal", ReturnType UComplexVector, [UComplexMatrix], OpenCL) ;
   add_unqualified ("dims", ReturnType (UArray UInt), [UComplex], AoS) ;
   add_unqualified ("dims", ReturnType (UArray UInt), [UInt], SoA) ;
   add_unqualified ("dims", ReturnType (UArray UInt), [UReal], SoA) ;
@@ -1139,14 +1155,14 @@ let () =
   add_unqualified ("distance", ReturnType UReal, [URowVector; URowVector], SoA) ;
   add_unqualified ("distance", ReturnType UReal, [UVector; URowVector], SoA) ;
   add_unqualified ("distance", ReturnType UReal, [URowVector; UVector], SoA) ;
-  add_unqualified ("divide", ReturnType UInt, [UInt; UInt], SoA) ;
-  add_unqualified ("divide", ReturnType UReal, [UReal; UReal], SoA) ;
-  add_unqualified ("divide", ReturnType UVector, [UVector; UReal], SoA) ;
-  add_unqualified ("divide", ReturnType URowVector, [URowVector; UReal], SoA) ;
-  add_unqualified ("divide", ReturnType UMatrix, [UMatrix; UReal], SoA) ;
-  add_unqualified ("divide", ReturnType UVector, [UReal; UVector], SoA) ;
-  add_unqualified ("divide", ReturnType URowVector, [UReal; URowVector], SoA) ;
-  add_unqualified ("divide", ReturnType UMatrix, [UReal; UMatrix], SoA) ;
+  add_unqualified ("divide", ReturnType UInt, [UInt; UInt], OpenCL) ;
+  add_unqualified ("divide", ReturnType UReal, [UReal; UReal], OpenCL) ;
+  add_unqualified ("divide", ReturnType UVector, [UVector; UReal], OpenCL) ;
+  add_unqualified ("divide", ReturnType URowVector, [URowVector; UReal], OpenCL) ;
+  add_unqualified ("divide", ReturnType UMatrix, [UMatrix; UReal], OpenCL) ;
+  add_unqualified ("divide", ReturnType UVector, [UReal; UVector], OpenCL) ;
+  add_unqualified ("divide", ReturnType URowVector, [UReal; URowVector], OpenCL) ;
+  add_unqualified ("divide", ReturnType UMatrix, [UReal; UMatrix], OpenCL) ;
   add_unqualified ("divide", ReturnType UComplex, [UComplex; UComplex], AoS) ;
   add_unqualified
     ("divide", ReturnType UComplexVector, [UComplexVector; UComplex], AoS) ;
@@ -1160,13 +1176,15 @@ let () =
     ("divide", ReturnType UComplexRowVector, [UComplex; UComplexRowVector], AoS) ;
   add_unqualified
     ("divide", ReturnType UComplexMatrix, [UComplex; UComplexMatrix], AoS) ;
-  add_unqualified ("dot_product", ReturnType UReal, [UVector; UVector], SoA) ;
+  add_unqualified ("dot_product", ReturnType UReal, [UVector; UVector], OpenCL) ;
+  add_unqualified
+    ("dot_product", ReturnType UReal, [URowVector; URowVector], OpenCL) ;
+  add_unqualified
+    ("dot_product", ReturnType UReal, [UVector; URowVector], OpenCL) ;
   add_unqualified
-    ("dot_product", ReturnType UReal, [URowVector; URowVector], SoA) ;
-  add_unqualified ("dot_product", ReturnType UReal, [UVector; URowVector], SoA) ;
-  add_unqualified ("dot_product", ReturnType UReal, [URowVector; UVector], SoA) ;
+    ("dot_product", ReturnType UReal, [URowVector; UVector], OpenCL) ;
   add_unqualified
-    ("dot_product", ReturnType UReal, [UArray UReal; UArray UReal], SoA) ;
+    ("dot_product", ReturnType UReal, [UArray UReal; UArray UReal], OpenCL) ;
   add_unqualified
     ("dot_product", ReturnType UComplex, [UComplexVector; UComplexVector], AoS) ;
   add_unqualified
@@ -1186,8 +1204,8 @@ let () =
     , AoS ) ;
   add_unqualified
     ("dot_product", ReturnType UComplex, [UArray UComplex; UArray UComplex], AoS) ;
-  add_unqualified ("dot_self", ReturnType UReal, [UVector], SoA) ;
-  add_unqualified ("dot_self", ReturnType UReal, [URowVector], SoA) ;
+  add_unqualified ("dot_self", ReturnType UReal, [UVector], OpenCL) ;
+  add_unqualified ("dot_self", ReturnType UReal, [URowVector], OpenCL) ;
   add_unqualified ("dot_self", ReturnType UComplex, [UComplexVector], AoS) ;
   add_unqualified ("dot_self", ReturnType UComplex, [UComplexRowVector], AoS) ;
   add_nullary "e" ;
@@ -1232,61 +1250,75 @@ let () =
   add_unqualified ("qr_thin_Q", ReturnType UMatrix, [UMatrix], AoS) ;
   add_unqualified ("qr_thin_R", ReturnType UMatrix, [UMatrix], AoS) ;
   List.iter
-    ~f:(fun x -> add_unqualified ("elt_divide", ReturnType x, [x; x], SoA))
+    ~f:(fun x -> add_unqualified ("elt_divide", ReturnType x, [x; x], OpenCL))
     bare_types ;
-  add_unqualified ("elt_divide", ReturnType UVector, [UVector; UReal], SoA) ;
-  add_unqualified ("elt_divide", ReturnType URowVector, [URowVector; UReal], SoA) ;
-  add_unqualified ("elt_divide", ReturnType UMatrix, [UMatrix; UReal], SoA) ;
-  add_unqualified ("elt_divide", ReturnType UVector, [UReal; UVector], SoA) ;
-  add_unqualified ("elt_divide", ReturnType URowVector, [UReal; URowVector], SoA) ;
-  add_unqualified ("elt_divide", ReturnType UMatrix, [UReal; UMatrix], SoA) ;
+  add_unqualified ("elt_divide", ReturnType UVector, [UVector; UReal], OpenCL) ;
   add_unqualified
-    ("elt_divide", ReturnType UComplexVector, [UComplexVector; UComplex], SoA) ;
+    ("elt_divide", ReturnType URowVector, [URowVector; UReal], OpenCL) ;
+  add_unqualified ("elt_divide", ReturnType UMatrix, [UMatrix; UReal], OpenCL) ;
+  add_unqualified ("elt_divide", ReturnType UVector, [UReal; UVector], OpenCL) ;
+  add_unqualified
+    ("elt_divide", ReturnType URowVector, [UReal; URowVector], OpenCL) ;
+  add_unqualified ("elt_divide", ReturnType UMatrix, [UReal; UMatrix], OpenCL) ;
+  add_unqualified
+    ("elt_divide", ReturnType UComplexVector, [UComplexVector; UComplex], OpenCL) ;
   add_unqualified
     ( "elt_divide"
     , ReturnType UComplexRowVector
     , [UComplexRowVector; UComplex]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
-    ("elt_divide", ReturnType UComplexMatrix, [UComplexMatrix; UComplex], SoA) ;
+    ("elt_divide", ReturnType UComplexMatrix, [UComplexMatrix; UComplex], OpenCL) ;
   add_unqualified
-    ("elt_divide", ReturnType UComplexVector, [UComplex; UComplexVector], SoA) ;
+    ("elt_divide", ReturnType UComplexVector, [UComplex; UComplexVector], OpenCL) ;
   add_unqualified
     ( "elt_divide"
     , ReturnType UComplexRowVector
     , [UComplex; UComplexRowVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
-    ("elt_divide", ReturnType UComplexMatrix, [UComplex; UComplexMatrix], SoA) ;
+    ("elt_divide", ReturnType UComplexMatrix, [UComplex; UComplexMatrix], OpenCL) ;
   List.iter
-    ~f:(fun x -> add_unqualified ("elt_multiply", ReturnType x, [x; x], SoA))
+    ~f:(fun x -> add_unqualified ("elt_multiply", ReturnType x, [x; x], OpenCL))
     bare_types ;
-  add_unqualified ("elt_multiply", ReturnType UVector, [UVector; UReal], SoA) ;
+  add_unqualified ("elt_multiply", ReturnType UVector, [UVector; UReal], OpenCL) ;
   add_unqualified
-    ("elt_multiply", ReturnType URowVector, [URowVector; UReal], SoA) ;
-  add_unqualified ("elt_multiply", ReturnType UMatrix, [UMatrix; UReal], SoA) ;
-  add_unqualified ("elt_multiply", ReturnType UVector, [UReal; UVector], SoA) ;
+    ("elt_multiply", ReturnType URowVector, [URowVector; UReal], OpenCL) ;
+  add_unqualified ("elt_multiply", ReturnType UMatrix, [UMatrix; UReal], OpenCL) ;
+  add_unqualified ("elt_multiply", ReturnType UVector, [UReal; UVector], OpenCL) ;
   add_unqualified
-    ("elt_multiply", ReturnType URowVector, [UReal; URowVector], SoA) ;
-  add_unqualified ("elt_multiply", ReturnType UMatrix, [UReal; UMatrix], SoA) ;
+    ("elt_multiply", ReturnType URowVector, [UReal; URowVector], OpenCL) ;
+  add_unqualified ("elt_multiply", ReturnType UMatrix, [UReal; UMatrix], OpenCL) ;
   add_unqualified
-    ("elt_multiply", ReturnType UComplexVector, [UComplexVector; UComplex], SoA) ;
+    ( "elt_multiply"
+    , ReturnType UComplexVector
+    , [UComplexVector; UComplex]
+    , OpenCL ) ;
   add_unqualified
     ( "elt_multiply"
     , ReturnType UComplexRowVector
     , [UComplexRowVector; UComplex]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
-    ("elt_multiply", ReturnType UComplexMatrix, [UComplexMatrix; UComplex], SoA) ;
+    ( "elt_multiply"
+    , ReturnType UComplexMatrix
+    , [UComplexMatrix; UComplex]
+    , OpenCL ) ;
   add_unqualified
-    ("elt_multiply", ReturnType UComplexVector, [UComplex; UComplexVector], SoA) ;
+    ( "elt_multiply"
+    , ReturnType UComplexVector
+    , [UComplex; UComplexVector]
+    , OpenCL ) ;
   add_unqualified
     ( "elt_multiply"
     , ReturnType UComplexRowVector
     , [UComplex; UComplexRowVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
-    ("elt_multiply", ReturnType UComplexMatrix, [UComplex; UComplexMatrix], SoA) ;
+    ( "elt_multiply"
+    , ReturnType UComplexMatrix
+    , [UComplex; UComplexMatrix]
+    , OpenCL ) ;
   add_unqualified ("exp", ReturnType UComplex, [UComplex], AoS) ;
   add_binary_vec_int_int "falling_factorial" SoA ;
   add_binary_vec_real_int "falling_factorial" SoA ;
@@ -1647,7 +1679,7 @@ let () =
     ("lkj_corr_cholesky_rng", ReturnType UMatrix, [UInt; UReal], AoS) ;
   add_unqualified ("lkj_corr_rng", ReturnType UMatrix, [UInt; UReal], AoS) ;
   add_binary_vec_int_real "lmgamma" AoS ;
-  add_binary_vec "lmultiply" SoA ;
+  add_binary_vec "lmultiply" OpenCL ;
   add_unqualified ("log", ReturnType UComplex, [UComplex], AoS) ;
   add_nullary "log10" ;
   add_unqualified ("log10", ReturnType UComplex, [UComplex], AoS) ;
@@ -1670,29 +1702,29 @@ let () =
     (List.tl_exn vector_types) ;
   add_binary_vec "log_modified_bessel_first_kind" AoS ;
   add_binary_vec "log_rising_factorial" AoS ;
-  add_unqualified ("log_softmax", ReturnType UVector, [UVector], SoA) ;
-  add_unqualified ("log_sum_exp", ReturnType UReal, [UArray UReal], SoA) ;
-  add_unqualified ("log_sum_exp", ReturnType UReal, [UVector], SoA) ;
-  add_unqualified ("log_sum_exp", ReturnType UReal, [URowVector], SoA) ;
-  add_unqualified ("log_sum_exp", ReturnType UReal, [UMatrix], SoA) ;
+  add_unqualified ("log_softmax", ReturnType UVector, [UVector], OpenCL) ;
+  add_unqualified ("log_sum_exp", ReturnType UReal, [UArray UReal], OpenCL) ;
+  add_unqualified ("log_sum_exp", ReturnType UReal, [UVector], OpenCL) ;
+  add_unqualified ("log_sum_exp", ReturnType UReal, [URowVector], OpenCL) ;
+  add_unqualified ("log_sum_exp", ReturnType UReal, [UMatrix], OpenCL) ;
   add_binary_vec "log_sum_exp" AoS ;
   let logical_binops =
     [ "logical_or"; "logical_and"; "logical_eq"; "logical_neq"; "logical_lt"
     ; "logical_lte"; "logical_gt"; "logical_gte" ] in
   List.iter
     ~f:(fun t1 ->
-      add_unqualified ("logical_negation", ReturnType UInt, [t1], SoA) ;
+      add_unqualified ("logical_negation", ReturnType UInt, [t1], OpenCL) ;
       List.iter
         ~f:(fun t2 ->
           List.iter
-            ~f:(fun o -> add_unqualified (o, ReturnType UInt, [t1; t2], SoA))
+            ~f:(fun o -> add_unqualified (o, ReturnType UInt, [t1; t2], OpenCL))
             logical_binops )
         primitive_types )
     primitive_types ;
-  add_unqualified ("logical_eq", ReturnType UInt, [UComplex; UReal], SoA) ;
-  add_unqualified ("logical_eq", ReturnType UInt, [UComplex; UComplex], SoA) ;
-  add_unqualified ("logical_neq", ReturnType UInt, [UComplex; UReal], SoA) ;
-  add_unqualified ("logical_neq", ReturnType UInt, [UComplex; UComplex], SoA) ;
+  add_unqualified ("logical_eq", ReturnType UInt, [UComplex; UReal], OpenCL) ;
+  add_unqualified ("logical_eq", ReturnType UInt, [UComplex; UComplex], OpenCL) ;
+  add_unqualified ("logical_neq", ReturnType UInt, [UComplex; UReal], OpenCL) ;
+  add_unqualified ("logical_neq", ReturnType UInt, [UComplex; UComplex], OpenCL) ;
   add_nullary "machine_precision" ;
   add_qualified
     ( "map_rect"
@@ -1710,7 +1742,7 @@ let () =
   add_unqualified ("matrix_exp", ReturnType UMatrix, [UMatrix], AoS) ;
   add_unqualified
     ("matrix_exp_multiply", ReturnType UMatrix, [UMatrix; UMatrix], AoS) ;
-  add_unqualified ("matrix_power", ReturnType UMatrix, [UMatrix; UInt], SoA) ;
+  add_unqualified ("matrix_power", ReturnType UMatrix, [UMatrix; UInt], OpenCL) ;
   add_unqualified ("max", ReturnType UInt, [UArray UInt], AoS) ;
   add_unqualified ("max", ReturnType UReal, [UArray UReal], AoS) ;
   add_unqualified ("max", ReturnType UReal, [UVector], AoS) ;
@@ -1748,7 +1780,7 @@ let () =
     ("mdivide_right_tri_low", ReturnType URowVector, [URowVector; UMatrix], AoS) ;
   add_unqualified
     ("mdivide_right_tri_low", ReturnType UMatrix, [UMatrix; UMatrix], AoS) ;
-  add_unqualified ("mean", ReturnType UReal, [UArray UReal], SoA) ;
+  add_unqualified ("mean", ReturnType UReal, [UArray UReal], AoS) ;
   add_unqualified ("mean", ReturnType UReal, [UVector], AoS) ;
   add_unqualified ("mean", ReturnType UReal, [URowVector], AoS) ;
   add_unqualified ("mean", ReturnType UReal, [UMatrix], AoS) ;
@@ -1831,83 +1863,89 @@ let () =
   add_unqualified
     ("multinomial_rng", ReturnType (UArray UInt), [UVector; UInt], AoS) ;
   add_unqualified ("multiply", ReturnType UComplex, [UComplex; UComplex], AoS) ;
-  add_unqualified ("multiply", ReturnType UInt, [UInt; UInt], SoA) ;
-  add_unqualified ("multiply", ReturnType UReal, [UReal; UReal], SoA) ;
-  add_unqualified ("multiply", ReturnType UVector, [UVector; UReal], SoA) ;
-  add_unqualified ("multiply", ReturnType URowVector, [URowVector; UReal], SoA) ;
-  add_unqualified ("multiply", ReturnType UMatrix, [UMatrix; UReal], SoA) ;
-  add_unqualified ("multiply", ReturnType UReal, [URowVector; UVector], SoA) ;
-  add_unqualified ("multiply", ReturnType UMatrix, [UVector; URowVector], SoA) ;
-  add_unqualified ("multiply", ReturnType UVector, [UMatrix; UVector], SoA) ;
-  add_unqualified ("multiply", ReturnType URowVector, [URowVector; UMatrix], SoA) ;
-  add_unqualified ("multiply", ReturnType UMatrix, [UMatrix; UMatrix], SoA) ;
-  add_unqualified ("multiply", ReturnType UVector, [UReal; UVector], SoA) ;
-  add_unqualified ("multiply", ReturnType URowVector, [UReal; URowVector], SoA) ;
-  add_unqualified ("multiply", ReturnType UMatrix, [UReal; UMatrix], SoA) ;
+  add_unqualified ("multiply", ReturnType UInt, [UInt; UInt], OpenCL) ;
+  add_unqualified ("multiply", ReturnType UReal, [UReal; UReal], OpenCL) ;
+  add_unqualified ("multiply", ReturnType UVector, [UVector; UReal], OpenCL) ;
+  add_unqualified
+    ("multiply", ReturnType URowVector, [URowVector; UReal], OpenCL) ;
+  add_unqualified ("multiply", ReturnType UMatrix, [UMatrix; UReal], OpenCL) ;
+  add_unqualified ("multiply", ReturnType UReal, [URowVector; UVector], OpenCL) ;
+  add_unqualified ("multiply", ReturnType UMatrix, [UVector; URowVector], OpenCL) ;
+  add_unqualified ("multiply", ReturnType UVector, [UMatrix; UVector], OpenCL) ;
+  add_unqualified
+    ("multiply", ReturnType URowVector, [URowVector; UMatrix], OpenCL) ;
+  add_unqualified ("multiply", ReturnType UMatrix, [UMatrix; UMatrix], OpenCL) ;
+  add_unqualified ("multiply", ReturnType UVector, [UReal; UVector], OpenCL) ;
+  add_unqualified
+    ("multiply", ReturnType URowVector, [UReal; URowVector], OpenCL) ;
+  add_unqualified ("multiply", ReturnType UMatrix, [UReal; UMatrix], OpenCL) ;
   (* TODO more complex overloads *)
   add_unqualified
     ( "multiply"
     , ReturnType UComplexMatrix
     , [UComplexMatrix; UComplexMatrix]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
-    ("multiply", ReturnType UComplexMatrix, [UComplexMatrix; UComplex], SoA) ;
+    ("multiply", ReturnType UComplexMatrix, [UComplexMatrix; UComplex], OpenCL) ;
   add_unqualified
-    ("multiply", ReturnType UComplexMatrix, [UComplex; UComplexMatrix], SoA) ;
+    ("multiply", ReturnType UComplexMatrix, [UComplex; UComplexMatrix], OpenCL) ;
   add_unqualified
     ( "multiply"
     , ReturnType UComplexMatrix
     , [UComplexVector; UComplexRowVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
-    ("multiply", ReturnType UComplex, [UComplexRowVector; UComplexVector], SoA) ;
+    ( "multiply"
+    , ReturnType UComplex
+    , [UComplexRowVector; UComplexVector]
+    , OpenCL ) ;
   add_unqualified
     ( "multiply"
     , ReturnType UComplexVector
     , [UComplexMatrix; UComplexVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
-    ("multiply", ReturnType UComplexVector, [UComplexVector; UComplex], SoA) ;
+    ("multiply", ReturnType UComplexVector, [UComplexVector; UComplex], OpenCL) ;
   add_unqualified
-    ("multiply", ReturnType UComplexVector, [UComplex; UComplexVector], SoA) ;
+    ("multiply", ReturnType UComplexVector, [UComplex; UComplexVector], OpenCL) ;
   add_unqualified
     ( "multiply"
     , ReturnType UComplexRowVector
     , [UComplexRowVector; UComplex]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "multiply"
     , ReturnType UComplexRowVector
     , [UComplex; UComplexRowVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "multiply"
     , ReturnType UComplexRowVector
     , [UComplexRowVector; UComplexMatrix]
-    , SoA ) ;
-  add_binary_vec "multiply_log" SoA ;
+    , OpenCL ) ;
+  add_binary_vec "multiply_log" OpenCL ;
   add_unqualified
-    ("multiply_lower_tri_self_transpose", ReturnType UMatrix, [UMatrix], SoA) ;
+    ("multiply_lower_tri_self_transpose", ReturnType UMatrix, [UMatrix], OpenCL) ;
   add_unqualified
     ( "neg_binomial_2_log_glm_lpmf"
     , ReturnType UReal
     , [UArray UInt; UMatrix; UVector; UVector; UReal]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "neg_binomial_2_log_glm_lpmf"
     , ReturnType UReal
     , [UInt; UMatrix; UVector; UVector; UReal]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "neg_binomial_2_log_glm_lpmf"
     , ReturnType UReal
     , [UArray UInt; URowVector; UReal; UVector; UReal]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "neg_binomial_2_log_glm_lpmf"
     , ReturnType UReal
     , [UArray UInt; URowVector; UVector; UVector; UReal]
-    , SoA ) ;
+    , OpenCL ) ;
   add_nullary "negative_infinity" ;
   add_unqualified ("norm", ReturnType UReal, [UComplex], AoS) ;
   add_unqualified ("norm1", ReturnType UReal, [UArray UReal], SoA) ;
@@ -1920,57 +1958,57 @@ let () =
     ( "normal_id_glm_lpdf"
     , ReturnType UReal
     , [UVector; UMatrix; UVector; UVector; UReal]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "normal_id_glm_lpdf"
     , ReturnType UReal
     , [UReal; UMatrix; UReal; UVector; UReal]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "normal_id_glm_lpdf"
     , ReturnType UReal
     , [UReal; UMatrix; UVector; UVector; UReal]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "normal_id_glm_lpdf"
     , ReturnType UReal
     , [UReal; UMatrix; UReal; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "normal_id_glm_lpdf"
     , ReturnType UReal
     , [UReal; UMatrix; UVector; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "normal_id_glm_lpdf"
     , ReturnType UReal
     , [UVector; URowVector; UReal; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "normal_id_glm_lpdf"
     , ReturnType UReal
     , [UVector; URowVector; UVector; UVector; UReal]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "normal_id_glm_lpdf"
     , ReturnType UReal
     , [UVector; URowVector; UVector; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "normal_id_glm_lpdf"
     , ReturnType UReal
     , [UVector; URowVector; UReal; UVector; UReal]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "normal_id_glm_lpdf"
     , ReturnType UReal
     , [UVector; UMatrix; UReal; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "normal_id_glm_lpdf"
     , ReturnType UReal
     , [UVector; UMatrix; UVector; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_nullary "not_a_number" ;
   add_unqualified ("num_elements", ReturnType UInt, [UMatrix], SoA) ;
   add_unqualified ("num_elements", ReturnType UInt, [UVector], SoA) ;
@@ -2000,32 +2038,32 @@ let () =
     ( "ordered_logistic_glm_lpmf"
     , ReturnType UReal
     , [UArray UInt; URowVector; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "ordered_logistic_glm_lpmf"
     , ReturnType UReal
     , [UInt; URowVector; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "ordered_logistic_log"
     , ReturnType UReal
     , [UArray UInt; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "ordered_logistic_log"
     , ReturnType UReal
     , [UArray UInt; UVector; UArray UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "ordered_logistic_lpmf"
     , ReturnType UReal
     , [UArray UInt; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "ordered_logistic_lpmf"
     , ReturnType UReal
     , [UArray UInt; UVector; UArray UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ("ordered_logistic_rng", ReturnType UInt, [UReal; UVector], AoS) ;
   add_unqualified
@@ -2059,31 +2097,31 @@ let () =
   add_binary_vec_real_real "owens_t" AoS ;
   add_nullary "pi" ;
   add_unqualified ("plus", ReturnType UComplex, [UComplex], AoS) ;
-  add_unqualified ("plus", ReturnType UInt, [UInt], SoA) ;
-  add_unqualified ("plus", ReturnType UReal, [UReal], SoA) ;
-  add_unqualified ("plus", ReturnType UVector, [UVector], SoA) ;
-  add_unqualified ("plus", ReturnType URowVector, [URowVector], SoA) ;
-  add_unqualified ("plus", ReturnType UMatrix, [UMatrix], SoA) ;
+  add_unqualified ("plus", ReturnType UInt, [UInt], OpenCL) ;
+  add_unqualified ("plus", ReturnType UReal, [UReal], OpenCL) ;
+  add_unqualified ("plus", ReturnType UVector, [UVector], OpenCL) ;
+  add_unqualified ("plus", ReturnType URowVector, [URowVector], OpenCL) ;
+  add_unqualified ("plus", ReturnType UMatrix, [UMatrix], OpenCL) ;
   add_unqualified
     ( "poisson_log_glm_lpmf"
     , ReturnType UReal
     , [UArray UInt; UMatrix; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "poisson_log_glm_lpmf"
     , ReturnType UReal
     , [UInt; UMatrix; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "poisson_log_glm_lpmf"
     , ReturnType UReal
     , [UArray UInt; URowVector; UReal; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
     ( "poisson_log_glm_lpmf"
     , ReturnType UReal
     , [UArray UInt; URowVector; UVector; UVector]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified ("polar", ReturnType UComplex, [UReal; UReal], AoS) ;
   add_nullary "positive_infinity" ;
   add_binary_vec "pow" AoS ;
@@ -2203,9 +2241,9 @@ let () =
             , SoA ) )
         (List.range 1 3) )
     bare_types ;
-  add_unqualified ("rep_matrix", ReturnType UMatrix, [UReal; UInt; UInt], SoA) ;
-  add_unqualified ("rep_matrix", ReturnType UMatrix, [UVector; UInt], SoA) ;
-  add_unqualified ("rep_matrix", ReturnType UMatrix, [URowVector; UInt], SoA) ;
+  add_unqualified ("rep_matrix", ReturnType UMatrix, [UReal; UInt; UInt], OpenCL) ;
+  add_unqualified ("rep_matrix", ReturnType UMatrix, [UVector; UInt], OpenCL) ;
+  add_unqualified ("rep_matrix", ReturnType UMatrix, [URowVector; UInt], OpenCL) ;
   add_unqualified
     ("rep_matrix", ReturnType UComplexMatrix, [UComplex; UInt; UInt], AoS) ;
   add_unqualified
@@ -2218,8 +2256,8 @@ let () =
   add_unqualified ("rep_vector", ReturnType UVector, [UReal; UInt], SoA) ;
   add_unqualified
     ("rep_vector", ReturnType UComplexVector, [UComplex; UInt], AoS) ;
-  add_unqualified ("reverse", ReturnType UVector, [UVector], SoA) ;
-  add_unqualified ("reverse", ReturnType URowVector, [URowVector], SoA) ;
+  add_unqualified ("reverse", ReturnType UVector, [UVector], OpenCL) ;
+  add_unqualified ("reverse", ReturnType URowVector, [URowVector], OpenCL) ;
   List.iter
     ~f:(fun i ->
       List.iter
@@ -2228,12 +2266,13 @@ let () =
             ( "reverse"
             , ReturnType (bare_array_type (t, i))
             , [bare_array_type (t, i)]
-            , SoA ) )
+            , OpenCL ) )
         bare_types )
     (List.range 1 8) ;
-  add_unqualified ("reverse", ReturnType UComplexVector, [UComplexVector], SoA) ;
   add_unqualified
-    ("reverse", ReturnType UComplexRowVector, [UComplexRowVector], SoA) ;
+    ("reverse", ReturnType UComplexVector, [UComplexVector], OpenCL) ;
+  add_unqualified
+    ("reverse", ReturnType UComplexRowVector, [UComplexRowVector], OpenCL) ;
   add_binary_vec_int_int "rising_factorial" AoS ;
   add_binary_vec_real_int "rising_factorial" AoS ;
   add_unqualified ("row", ReturnType URowVector, [UMatrix; UInt], SoA) ;
@@ -2250,7 +2289,7 @@ let () =
   add_unqualified
     ("rows_dot_product", ReturnType UVector, [URowVector; URowVector], AoS) ;
   add_unqualified
-    ("rows_dot_product", ReturnType UVector, [UMatrix; UMatrix], SoA) ;
+    ("rows_dot_product", ReturnType UVector, [UMatrix; UMatrix], OpenCL) ;
   add_unqualified
     ( "rows_dot_product"
     , ReturnType UComplexVector
@@ -2266,9 +2305,9 @@ let () =
     , ReturnType UComplexVector
     , [UComplexMatrix; UComplexMatrix]
     , AoS ) ;
-  add_unqualified ("rows_dot_self", ReturnType UVector, [UVector], SoA) ;
-  add_unqualified ("rows_dot_self", ReturnType UVector, [URowVector], SoA) ;
-  add_unqualified ("rows_dot_self", ReturnType UVector, [UMatrix], SoA) ;
+  add_unqualified ("rows_dot_self", ReturnType UVector, [UVector], OpenCL) ;
+  add_unqualified ("rows_dot_self", ReturnType UVector, [URowVector], OpenCL) ;
+  add_unqualified ("rows_dot_self", ReturnType UVector, [UMatrix], OpenCL) ;
   add_unqualified
     ("rows_dot_self", ReturnType UComplexVector, [UComplexVector], AoS) ;
   add_unqualified
@@ -2280,10 +2319,10 @@ let () =
     , ReturnType UMatrix
     , [UReal; UMatrix; UMatrix]
     , AoS ) ;
-  add_unqualified ("sd", ReturnType UReal, [UArray UReal], SoA) ;
-  add_unqualified ("sd", ReturnType UReal, [UVector], SoA) ;
-  add_unqualified ("sd", ReturnType UReal, [URowVector], SoA) ;
-  add_unqualified ("sd", ReturnType UReal, [UMatrix], SoA) ;
+  add_unqualified ("sd", ReturnType UReal, [UArray UReal], OpenCL) ;
+  add_unqualified ("sd", ReturnType UReal, [UVector], OpenCL) ;
+  add_unqualified ("sd", ReturnType UReal, [URowVector], OpenCL) ;
+  add_unqualified ("sd", ReturnType UReal, [UMatrix], OpenCL) ;
   add_unqualified
     ("segment", ReturnType URowVector, [URowVector; UInt; UInt], SoA) ;
   add_unqualified ("segment", ReturnType UVector, [UVector; UInt; UInt], SoA) ;
@@ -2320,7 +2359,7 @@ let () =
   List.iter
     ~f:(fun t -> add_unqualified ("size", ReturnType UInt, [t], SoA))
     bare_types ;
-  add_unqualified ("softmax", ReturnType UVector, [UVector], SoA) ;
+  add_unqualified ("softmax", ReturnType UVector, [UVector], OpenCL) ;
   add_unqualified ("sort_asc", ReturnType (UArray UInt), [UArray UInt], AoS) ;
   add_unqualified ("sort_asc", ReturnType (UArray UReal), [UArray UReal], AoS) ;
   add_unqualified ("sort_asc", ReturnType UVector, [UVector], AoS) ;
@@ -2343,14 +2382,15 @@ let () =
   add_unqualified ("sort_indices_desc", ReturnType (UArray UInt), [UVector], AoS) ;
   add_unqualified
     ("sort_indices_desc", ReturnType (UArray UInt), [URowVector], AoS) ;
-  add_unqualified ("squared_distance", ReturnType UReal, [UReal; UReal], SoA) ;
-  add_unqualified ("squared_distance", ReturnType UReal, [UVector; UVector], SoA) ;
+  add_unqualified ("squared_distance", ReturnType UReal, [UReal; UReal], OpenCL) ;
+  add_unqualified
+    ("squared_distance", ReturnType UReal, [UVector; UVector], OpenCL) ;
   add_unqualified
-    ("squared_distance", ReturnType UReal, [URowVector; URowVector], SoA) ;
+    ("squared_distance", ReturnType UReal, [URowVector; URowVector], OpenCL) ;
   add_unqualified
-    ("squared_distance", ReturnType UReal, [UVector; URowVector], SoA) ;
+    ("squared_distance", ReturnType UReal, [UVector; URowVector], OpenCL) ;
   add_unqualified
-    ("squared_distance", ReturnType UReal, [URowVector; UVector], SoA) ;
+    ("squared_distance", ReturnType UReal, [URowVector; UVector], OpenCL) ;
   add_unqualified ("sqrt", ReturnType UComplex, [UComplex], AoS) ;
   add_nullary "sqrt2" ;
   add_unqualified
@@ -2368,42 +2408,44 @@ let () =
     , [UComplexMatrix; UInt; UInt; UInt]
     , AoS ) ;
   List.iter
-    ~f:(fun x -> add_unqualified ("subtract", ReturnType x, [x; x], SoA))
+    ~f:(fun x -> add_unqualified ("subtract", ReturnType x, [x; x], OpenCL))
     bare_types ;
-  add_unqualified ("subtract", ReturnType UVector, [UVector; UReal], SoA) ;
-  add_unqualified ("subtract", ReturnType URowVector, [URowVector; UReal], SoA) ;
-  add_unqualified ("subtract", ReturnType UMatrix, [UMatrix; UReal], SoA) ;
-  add_unqualified ("subtract", ReturnType UVector, [UReal; UVector], SoA) ;
-  add_unqualified ("subtract", ReturnType URowVector, [UReal; URowVector], SoA) ;
-  add_unqualified ("subtract", ReturnType UMatrix, [UReal; UMatrix], SoA) ;
+  add_unqualified ("subtract", ReturnType UVector, [UVector; UReal], OpenCL) ;
+  add_unqualified
+    ("subtract", ReturnType URowVector, [URowVector; UReal], OpenCL) ;
+  add_unqualified ("subtract", ReturnType UMatrix, [UMatrix; UReal], OpenCL) ;
+  add_unqualified ("subtract", ReturnType UVector, [UReal; UVector], OpenCL) ;
+  add_unqualified
+    ("subtract", ReturnType URowVector, [UReal; URowVector], OpenCL) ;
+  add_unqualified ("subtract", ReturnType UMatrix, [UReal; UMatrix], OpenCL) ;
   add_unqualified
-    ("subtract", ReturnType UComplexVector, [UComplexVector; UComplex], SoA) ;
+    ("subtract", ReturnType UComplexVector, [UComplexVector; UComplex], OpenCL) ;
   add_unqualified
     ( "subtract"
     , ReturnType UComplexRowVector
     , [UComplexRowVector; UComplex]
-    , SoA ) ;
+    , OpenCL ) ;
   add_unqualified
-    ("subtract", ReturnType UComplexMatrix, [UComplexMatrix; UComplex], SoA) ;
+    ("subtract", ReturnType UComplexMatrix, [UComplexMatrix; UComplex], OpenCL) ;
   add_unqualified
-    ("subtract", ReturnType UComplexVector, [UComplex; UComplexVector], SoA) ;
+    ("subtract", ReturnType UComplexVector, [UComplex; UComplexVector], OpenCL) ;
   add_unqualified
     ( "subtract"
     , ReturnType UComplexRowVector
     , [UComplex; UComplexRowVector]
-    , SoA ) ;
-  add_unqualified
-    ("subtract", ReturnType UComplexMatrix, [UComplex; UComplexMatrix], SoA) ;
-  add_unqualified ("sum", ReturnType UInt, [UArray UInt], SoA) ;
-  add_unqualified ("sum", ReturnType UReal, [UArray UReal], SoA) ;
-  add_unqualified ("sum", ReturnType UReal, [UVector], SoA) ;
-  add_unqualified ("sum", ReturnType UReal, [URowVector], SoA) ;
-  add_unqualified ("sum", ReturnType UReal, [UMatrix], SoA) ;
-  add_unqualified ("sum", ReturnType UComplex, [UArray UComplex], SoA) ;
-  add_unqualified ("sum", ReturnType UComplex, [UComplexVector], SoA) ;
-  add_unqualified ("sum", ReturnType UComplex, [UComplexRowVector], SoA) ;
-  add_unqualified ("sum", ReturnType UComplex, [UComplexMatrix], SoA) ;
-  (* TODO (future): SoA inside of tuples, update following signatures *)
+    , OpenCL ) ;
+  add_unqualified
+    ("subtract", ReturnType UComplexMatrix, [UComplex; UComplexMatrix], OpenCL) ;
+  add_unqualified ("sum", ReturnType UInt, [UArray UInt], OpenCL) ;
+  add_unqualified ("sum", ReturnType UReal, [UArray UReal], OpenCL) ;
+  add_unqualified ("sum", ReturnType UReal, [UVector], OpenCL) ;
+  add_unqualified ("sum", ReturnType UReal, [URowVector], OpenCL) ;
+  add_unqualified ("sum", ReturnType UReal, [UMatrix], OpenCL) ;
+  add_unqualified ("sum", ReturnType UComplex, [UArray UComplex], OpenCL) ;
+  add_unqualified ("sum", ReturnType UComplex, [UComplexVector], OpenCL) ;
+  add_unqualified ("sum", ReturnType UComplex, [UComplexRowVector], OpenCL) ;
+  add_unqualified ("sum", ReturnType UComplex, [UComplexMatrix], OpenCL) ;
+  (* TODO (future): OpenCL inside of tuples, update following signatures *)
   add_unqualified
     ("svd", ReturnType (UTuple [UMatrix; UVector; UMatrix]), [UMatrix], AoS) ;
   add_unqualified
@@ -2441,7 +2483,7 @@ let () =
     bare_types ;
   add_unqualified ("tan", ReturnType UComplex, [UComplex], AoS) ;
   add_unqualified ("tanh", ReturnType UComplex, [UComplex], AoS) ;
-  add_unqualified ("tcrossprod", ReturnType UMatrix, [UMatrix], SoA) ;
+  add_unqualified ("tcrossprod", ReturnType UMatrix, [UMatrix], OpenCL) ;
   add_unqualified ("to_array_1d", ReturnType (UArray UReal), [UMatrix], AoS) ;
   add_unqualified ("to_array_1d", ReturnType (UArray UReal), [UVector], AoS) ;
   add_unqualified ("to_array_1d", ReturnType (UArray UReal), [URowVector], AoS) ;
@@ -2577,25 +2619,26 @@ let () =
     ("to_vector", ReturnType UComplexVector, [UComplexRowVector], AoS) ;
   add_unqualified
     ("to_vector", ReturnType UComplexVector, [UArray UComplex], AoS) ;
-  add_unqualified ("trace", ReturnType UReal, [UMatrix], SoA) ;
+  add_unqualified ("trace", ReturnType UReal, [UMatrix], OpenCL) ;
   add_unqualified ("trace", ReturnType UComplex, [UComplexMatrix], AoS) ;
   add_unqualified
     ("trace_gen_quad_form", ReturnType UReal, [UMatrix; UMatrix; UMatrix], SoA) ;
   add_unqualified ("trace_quad_form", ReturnType UReal, [UMatrix; UVector], SoA) ;
   add_unqualified ("trace_quad_form", ReturnType UReal, [UMatrix; UMatrix], SoA) ;
-  add_unqualified ("transpose", ReturnType URowVector, [UVector], SoA) ;
-  add_unqualified ("transpose", ReturnType UVector, [URowVector], SoA) ;
-  add_unqualified ("transpose", ReturnType UMatrix, [UMatrix], SoA) ;
+  add_unqualified ("transpose", ReturnType URowVector, [UVector], OpenCL) ;
+  add_unqualified ("transpose", ReturnType UVector, [URowVector], OpenCL) ;
+  add_unqualified ("transpose", ReturnType UMatrix, [UMatrix], OpenCL) ;
+  add_unqualified
+    ("transpose", ReturnType UComplexRowVector, [UComplexVector], OpenCL) ;
   add_unqualified
-    ("transpose", ReturnType UComplexRowVector, [UComplexVector], SoA) ;
+    ("transpose", ReturnType UComplexVector, [UComplexRowVector], OpenCL) ;
   add_unqualified
-    ("transpose", ReturnType UComplexVector, [UComplexRowVector], SoA) ;
-  add_unqualified ("transpose", ReturnType UComplexMatrix, [UComplexMatrix], SoA) ;
+    ("transpose", ReturnType UComplexMatrix, [UComplexMatrix], OpenCL) ;
   add_unqualified ("uniform_simplex", ReturnType UVector, [UInt], SoA) ;
-  add_unqualified ("variance", ReturnType UReal, [UArray UReal], SoA) ;
-  add_unqualified ("variance", ReturnType UReal, [UVector], SoA) ;
-  add_unqualified ("variance", ReturnType UReal, [URowVector], SoA) ;
-  add_unqualified ("variance", ReturnType UReal, [UMatrix], SoA) ;
+  add_unqualified ("variance", ReturnType UReal, [UArray UReal], OpenCL) ;
+  add_unqualified ("variance", ReturnType UReal, [UVector], OpenCL) ;
+  add_unqualified ("variance", ReturnType UReal, [URowVector], OpenCL) ;
+  add_unqualified ("variance", ReturnType UReal, [UMatrix], OpenCL) ;
   add_unqualified
     ("wishart_cholesky_rng", ReturnType UMatrix, [UReal; UMatrix], AoS) ;
   add_unqualified ("wishart_rng", ReturnType UMatrix, [UReal; UMatrix], AoS) ;
diff --git a/src/middle/Stmt.ml b/src/middle/Stmt.ml
index c67537a21..bbf77fb45 100644
--- a/src/middle/Stmt.ml
+++ b/src/middle/Stmt.ml
@@ -245,7 +245,7 @@ module Helpers = struct
 *)
   let rec for_scalar st bodyfn var smeta =
     match st with
-    | SizedType.SInt | SReal | SComplex -> bodyfn st var
+    | SizedType.SInt _ | SReal _ | SComplex -> bodyfn st var
     | SVector (_, d)
      |SRowVector (_, d)
      |SComplexVector d
@@ -259,7 +259,7 @@ module Helpers = struct
         mk_for_iteratee d1
           (fun e -> for_scalar (SComplexRowVector d2) bodyfn e smeta)
           var smeta
-    | SArray (t, d) ->
+    | SArray (_, t, d) ->
         mk_for_iteratee d (fun e -> for_scalar t bodyfn e smeta) var smeta
     | STuple _ -> bodyfn st var
 
@@ -274,7 +274,7 @@ module Helpers = struct
       | _ -> e in
     let rec go st bodyfn var smeta =
       match st with
-      | SizedType.SArray (t, d) ->
+      | SizedType.SArray (_, t, d) ->
           let bodyfn' _ var = mk_for_iteratee d (bodyfn st) var smeta in
           go t bodyfn' var smeta
       | SMatrix (mem_pattern, d1, d2) ->
diff --git a/src/middle/Utils.ml b/src/middle/Utils.ml
index 7ee459311..4b48589a7 100644
--- a/src/middle/Utils.ml
+++ b/src/middle/Utils.ml
@@ -90,7 +90,7 @@ let zip_stuple_trans_exn pst tms =
   let rec tuple_subtypes pst =
     match pst with
     | SizedType.STuple subtypes -> subtypes
-    | SArray (st, _) -> tuple_subtypes st
+    | SArray (_, st, _) -> tuple_subtypes st
     | _ ->
         Common.FatalError.fatal_error_msg
           [%message "Internal error: expected Tuple with TupleTransformation"]
diff --git a/src/stan_math_backend/Cpp.ml b/src/stan_math_backend/Cpp.ml
index 3b33a0158..568d10bd5 100644
--- a/src/stan_math_backend/Cpp.ml
+++ b/src/stan_math_backend/Cpp.ml
@@ -1,6 +1,7 @@
 (** A set of data types representing the C++ we generate *)
 
 open Core_kernel
+open Middle
 
 type identifier = string [@@deriving sexp]
 
@@ -8,15 +9,16 @@ type identifier = string [@@deriving sexp]
 type type_ =
   | Auto
   | Void
-  | Int
-  | Double
+  | Int of Mem_pattern.t
+  | Double of Mem_pattern.t
   | Complex of type_
   | TemplateType of identifier
-  | StdVector of type_
+  | StdVector of type_ * Mem_pattern.t
       (** A std::vector. For Eigen Vectors, use [Matrix] with a row or column size of 1 *)
-  | Array of type_ * int
+  | Array of type_ * int * Mem_pattern.t
   | Tuple of type_ list
-  | TypeLiteral of identifier  (** Used for things like Eigen::Index *)
+  | TypeLiteral of identifier * Mem_pattern.t
+      (** Used for things like Eigen::Index *)
   | Matrix of type_ * int * int * Middle.Mem_pattern.t
   | Ref of type_
   | Const of type_
@@ -28,12 +30,12 @@ type type_ =
 module Types = struct
   (** Helpers for constructing types *)
 
-  let local_scalar = TypeLiteral "local_scalar_t__"
+  let local_scalar mem_pattern = TypeLiteral ("local_scalar_t__", mem_pattern)
 
   (** A [std::vector<t>] *)
-  let std_vector t = StdVector t
+  let std_vector (t, mem) = StdVector (t, mem)
 
-  let bool = TypeLiteral "bool"
+  let bool = TypeLiteral ("bool", AoS)
   let complex s = Complex s
 
   (** An [Eigen::Matrix<s, -1, 1>]*)
@@ -49,11 +51,13 @@ module Types = struct
     Matrix (s, -1, -1, mem_pattern)
 
   (** A [std::string]*)
-  let string = TypeLiteral "std::string"
+  let string = TypeLiteral ("std::string", AoS)
 
-  let size_t = TypeLiteral "size_t"
+  let size_t = TypeLiteral ("size_t", AoS)
   let const_ref t = Const (Ref t)
-  let const_char_array i = Array (Const (Pointer (TypeLiteral "char")), i)
+
+  let const_char_array i =
+    Array (Const (Pointer (TypeLiteral ("char", AoS))), i, Mem_pattern.AoS)
 end
 
 type operator =
@@ -114,7 +118,8 @@ module Exprs = struct
   let literal_string s = Literal ("\"" ^ Cpp_str.escaped s ^ "\"")
 
   (** Equivalent to [std::vector<t>{e1,...,en}] *)
-  let std_vector_init_expr t elements = InitializerExpr (StdVector t, elements)
+  let std_vector_init_expr t elements =
+    InitializerExpr (StdVector (t, Mem_pattern.AoS), elements)
 
   let fun_call name args = FunCall (name, [], args)
   let templated_fun_call name templates args = FunCall (name, templates, args)
@@ -234,7 +239,7 @@ module Stmts = struct
     | _ ->
         [ TryCatch
             ( stmts
-            , (Types.const_ref (TypeLiteral "std::exception"), "e")
+            , (Types.const_ref (TypeLiteral ("std::exception", AoS)), "e")
             , [ Expression
                   (FunCall
                      ( "stan::lang::rethrow_located"
@@ -246,8 +251,8 @@ module Stmts = struct
 
   let fori loopvar lower upper body =
     let init =
-      make_variable_defn ~type_:Int ~name:loopvar ~init:(Assignment lower) ()
-    in
+      make_variable_defn ~type_:(Int AoS) ~name:loopvar ~init:(Assignment lower)
+        () in
     let stop = BinOp (Var loopvar, LEq, upper) in
     let incr = Increment (Var loopvar) in
     For (init, stop, incr, body)
@@ -264,12 +269,12 @@ module Decls = struct
 
   let current_statement =
     VariableDefn
-      (make_variable_defn ~type_:Int ~name:"current_statement__"
+      (make_variable_defn ~type_:(Int AoS) ~name:"current_statement__"
          ~init:(Assignment (Literal "0")) () )
 
   let dummy_var =
     VariableDefn
-      (make_variable_defn ~type_:Types.local_scalar ~name:"DUMMY_VAR__"
+      (make_variable_defn ~type_:(Types.local_scalar AoS) ~name:"DUMMY_VAR__"
          ~init:(Construction [Exprs.quiet_NaN])
          () )
     :: Stmts.unused "DUMMY_VAR__"
@@ -277,7 +282,7 @@ module Decls = struct
   let serializer_in =
     VariableDefn
       (make_variable_defn
-         ~type_:(TypeTrait ("stan::io::deserializer", [Types.local_scalar]))
+         ~type_:(TypeTrait ("stan::io::deserializer", [Types.local_scalar AoS]))
          ~name:"in__"
          ~init:(Construction [Var "params_r__"; Var "params_i__"])
          () )
@@ -285,7 +290,7 @@ module Decls = struct
   let serializer_out =
     VariableDefn
       (make_variable_defn
-         ~type_:(TypeTrait ("stan::io::serializer", [Types.local_scalar]))
+         ~type_:(TypeTrait ("stan::io::serializer", [Types.local_scalar AoS]))
          ~name:"out__"
          ~init:(Construction [Var "vars__"])
          () )
@@ -385,28 +390,51 @@ module Printing = struct
   let trailing_space (t : 'a Fmt.t) : 'a Fmt.t = fun ppf -> pf ppf "%a@ " t
   let pp_identifier ppf = string ppf
 
-  let rec pp_type_ ppf t =
+  let rec pp_type_ ppf (t : type_) =
+    let is_base_scalar_type = function
+      | Auto | Int _ | Double _ -> true
+      | _ -> false in
     match t with
     | Auto -> string ppf "auto"
     | Void -> string ppf "void"
-    | Int -> string ppf "int"
-    | Double -> string ppf "double"
+    | Int mem when Mem_pattern.is_opencl mem ->
+        string ppf "stan::math::matrix_cl<int>"
+    | Int _ -> string ppf "int"
+    | Double mem when Mem_pattern.is_opencl mem ->
+        string ppf "stan::math::matrix_cl<double>"
+    | Double _ -> string ppf "double"
     | Complex t -> pf ppf "std::complex<%a>" pp_type_ t
     | TemplateType id -> pp_identifier ppf id
-    | StdVector t -> pf ppf "@[<2>std::vector<@,%a>@]" pp_type_ t
-    | Array (t, i) -> pf ppf "@[<2>std::array<@,%a,@ %i>@]" pp_type_ t i
+    | StdVector (inner_t, mem)
+      when Mem_pattern.is_opencl mem && is_base_scalar_type inner_t -> (
+      match inner_t with
+      | Double _ -> pf ppf "@[<2>stan::math::matrix_cl<@,%a>@]" pp_type_ inner_t
+      | Int _ -> pf ppf "@[<2>stan::math::matrix_cl<@,%a>@]" pp_type_ inner_t
+      | _ -> pf ppf "@[<2>std::vector<@,%a>@]" pp_type_ inner_t )
+    | StdVector (inner_t, _) ->
+        pf ppf "@[<2>std::vector<@,%a>@]" pp_type_ inner_t
+    | Array (inner_t, _, mem) when Mem_pattern.is_opencl mem ->
+        pf ppf "@[<2>stan::math::matrix_cl<@,%a>@]" pp_type_ inner_t
+    | Array (inner_t, i, _) ->
+        pf ppf "@[<2>std::array<@,%a,@ %i>@]" pp_type_ inner_t i
     | Tuple subtypes ->
         pf ppf "@[<2>std::tuple<@,%a>@]" (list ~sep:comma pp_type_) subtypes
-    | TypeLiteral id -> pp_identifier ppf id
-    | Matrix (t, i, j, mem_pattern) -> (
+    | TypeLiteral (id, mem) when Mem_pattern.is_opencl mem ->
+        pf ppf "@[<2>stan::math::matrix_cl<@,%a>@]" pp_identifier id
+    | TypeLiteral (id, _) -> pp_identifier ppf id
+    | Matrix (inner_t, i, j, mem_pattern) -> (
       match mem_pattern with
       | Middle.Mem_pattern.AoS ->
-          pf ppf "Eigen::Matrix<%a,%i,%i>" pp_type_ t i j
-      | Middle.Mem_pattern.SoA ->
-          pf ppf "stan::math::var_value<Eigen::Matrix<double,%i,%i>>" i j )
-    | Const t -> pf ppf "const %a" pp_type_ t
-    | Ref t -> pf ppf "%a&" pp_type_ t
-    | Pointer t -> pf ppf "%a*" pp_type_ t
+          pf ppf "Eigen::Matrix<%a,%i,%i>" pp_type_ inner_t i j
+      | SoA -> pf ppf "stan::math::var_value<Eigen::Matrix<double,%i,%i>>" i j
+      | OpenCL -> (
+        match inner_t with
+        | Double _ -> pf ppf "stan::math::matrix_cl<double>"
+        | Int _ -> pf ppf "stan::math::matrix_cl<int>"
+        | _ -> pf ppf "stan::math::var_value<stan::math::matrix_cl<double>>" ) )
+    | Const inner_t -> pf ppf "const %a" pp_type_ inner_t
+    | Ref inner_t -> pf ppf "%a&" pp_type_ inner_t
+    | Pointer inner_t -> pf ppf "%a*" pp_type_ inner_t
     | TypeTrait (s, types) ->
         pf ppf "@[<2>%s<%a>@]" s (list ~sep:comma pp_type_) types
 
@@ -726,8 +754,9 @@ module Tests = struct
   let%expect_test "types" =
     let ts =
       let open Types in
-      [ matrix (complex local_scalar); const_char_array 43
-      ; std_vector (std_vector Double); const_ref (TemplateType "T0__") ] in
+      [ matrix (complex (local_scalar AoS)); const_char_array 43
+      ; std_vector (std_vector (Double Mem_pattern.AoS, AoS), AoS)
+      ; const_ref (TemplateType "T0__") ] in
     let open Fmt in
     pf stdout "@[<v>%a@]" (list ~sep:comma Printing.pp_type_) ts ;
     [%expect
@@ -742,7 +771,7 @@ module Tests = struct
   let%expect_test "eigen init" =
     let open Expression_syntax in
     let open Types in
-    let vector = Constructor (row_vector Double, [Literal "3"]) in
+    let vector = Constructor (row_vector (Double AoS), [Literal "3"]) in
     let values = [Literal "1"; Var "a"; Literal "3"] in
     let e = (vector << values).@!("finished") in
     print_s [%sexp (e : expr)] ;
@@ -752,7 +781,7 @@ module Tests = struct
       {|
           (MethodCall
            (Parens
-            (StreamInsertion (Constructor (Matrix Double 1 -1 AoS) ((Literal 3)))
+            (StreamInsertion (Constructor (Matrix (Double AoS) 1 -1 AoS) ((Literal 3)))
              ((Literal 1) (Var a) (Literal 3))))
            finished () ())
 
diff --git a/src/stan_math_backend/Cpp_Json.ml b/src/stan_math_backend/Cpp_Json.ml
index 8ccb27ddb..9fc15ad65 100644
--- a/src/stan_math_backend/Cpp_Json.ml
+++ b/src/stan_math_backend/Cpp_Json.ml
@@ -7,8 +7,8 @@ let rec sizedtype_to_json (st : Expr.Typed.t SizedType.t) : Yojson.Basic.t =
     Fmt.str "+ std::to_string(%a) +" Cpp.Printing.pp_expr
       (Lower_expr.lower_expr e) in
   match st with
-  | SInt -> `Assoc [("name", `String "int")]
-  | SReal -> `Assoc [("name", `String "real")]
+  | SInt _ -> `Assoc [("name", `String "int")]
+  | SReal _ -> `Assoc [("name", `String "real")]
   | SComplex -> `Assoc [("name", `String "complex")]
   | SVector (_, d) | SRowVector (_, d) ->
       `Assoc [("name", `String "vector"); ("length", `String (emit_cpp_expr d))]
@@ -25,7 +25,7 @@ let rec sizedtype_to_json (st : Expr.Typed.t SizedType.t) : Yojson.Basic.t =
         [ ("name", `String "complex_matrix")
         ; ("rows", `String (emit_cpp_expr d1))
         ; ("cols", `String (emit_cpp_expr d2)) ]
-  | SArray (st, d) ->
+  | SArray (_, st, d) ->
       `Assoc
         [ ("name", `String "array"); ("length", `String (emit_cpp_expr d))
         ; ("element_type", sizedtype_to_json st) ]
@@ -48,7 +48,7 @@ let%expect_test "outvar to json pretty" =
        vector[N] var_one[K];
      }
   *)
-  ("var_one", SArray (SVector (Mem_pattern.AoS, var "N"), var "K"), Parameters)
+  ("var_one", SArray (AoS, SVector (AoS, var "N"), var "K"), Parameters)
   |> out_var_json |> Yojson.Basic.pretty_to_string |> print_endline ;
   [%expect
     {|
@@ -80,7 +80,7 @@ let out_var_interpolated_json_str vars =
 let%expect_test "outvar to json" =
   let var x = {Expr.Fixed.pattern= Var x; meta= Expr.Typed.Meta.empty} in
   [ ( "var_one"
-    , SizedType.SArray (SVector (AoS, var "N"), var "K")
+    , SizedType.SArray (AoS, SVector (AoS, var "N"), var "K")
     , Program.Parameters ) ]
   |> out_var_interpolated_json_str |> print_endline ;
   [%expect
diff --git a/src/stan_math_backend/Lower_expr.ml b/src/stan_math_backend/Lower_expr.ml
index b4d3d5283..400faac02 100644
--- a/src/stan_math_backend/Lower_expr.ml
+++ b/src/stan_math_backend/Lower_expr.ml
@@ -95,10 +95,10 @@ let suffix_args = function
   | FnTarget -> ["lp__"; "lp_accum__"]
   | FnPlain | FnLpdf _ -> []
 
-let rec stantype_prim = function
-  | UnsizedType.UInt -> Int
+let rec stantype_prim ?(mem_pattern = Mem_pattern.AoS) = function
+  | UnsizedType.UInt -> Int mem_pattern
   | UArray t -> stantype_prim t
-  | _ -> Double
+  | _ -> Double mem_pattern
 
 let templates udf suffix =
   match suffix with
@@ -109,11 +109,12 @@ let templates udf suffix =
 
 let deserializer = Var "in__"
 
-let rec local_scalar ut ad =
+let rec local_scalar ?(mem_pattern = Mem_pattern.AoS) ut ad =
   match (ut, ad) with
-  | UnsizedType.UArray t, _ -> local_scalar t ad
-  | _, UnsizedType.DataOnly | UInt, AutoDiffable -> stantype_prim ut
-  | _, AutoDiffable -> Types.local_scalar
+  | UnsizedType.UArray t, _ -> local_scalar ~mem_pattern t ad
+  | _, UnsizedType.DataOnly | UInt, AutoDiffable ->
+      stantype_prim ~mem_pattern ut
+  | _, AutoDiffable -> Types.local_scalar mem_pattern
   | _, TupleAD _ ->
       Common.FatalError.fatal_error_msg
         [%message
@@ -132,10 +133,10 @@ let plus_one e =
 let rec lower_type ?(mem_pattern = Mem_pattern.AoS) (t : UnsizedType.t)
     (scalar : type_) : type_ =
   match t with
-  | UInt -> Int
+  | UInt -> Int mem_pattern
   | UReal -> scalar
   | UComplex -> Types.complex scalar
-  | UArray t -> StdVector (lower_type t scalar)
+  | UArray t -> StdVector (lower_type t scalar, mem_pattern)
   | UTuple ts -> Tuple (List.map ~f:(fun t -> lower_type t scalar) ts)
   | UVector -> Types.vector ~mem_pattern scalar
   | URowVector -> Types.row_vector ~mem_pattern scalar
@@ -152,7 +153,8 @@ let rec lower_unsizedtype_local ?(mem_pattern = Mem_pattern.AoS) adtype ut =
   | UnsizedType.TupleAD ads, UnsizedType.UTuple ts ->
       Tuple (List.map2_exn ~f:(lower_unsizedtype_local ~mem_pattern) ads ts)
   | UnsizedType.TupleAD _, UnsizedType.UArray t ->
-      Types.std_vector (lower_unsizedtype_local ~mem_pattern adtype t)
+      Types.std_vector
+        (lower_unsizedtype_local ~mem_pattern adtype t, mem_pattern)
   | _, UnsizedType.UTuple _ | TupleAD _, _ ->
       Common.FatalError.fatal_error_msg
         [%message
@@ -160,19 +162,21 @@ let rec lower_unsizedtype_local ?(mem_pattern = Mem_pattern.AoS) adtype ut =
             (ut : UnsizedType.t)
             (adtype : UnsizedType.autodifftype)]
   | _, _ ->
-      let s = local_scalar ut adtype in
+      let s = local_scalar ~mem_pattern ut adtype in
       lower_type ~mem_pattern ut s
 
 let rec lower_possibly_var_decl adtype ut mem_pattern =
   let var_decl p_ut = lower_unsizedtype_local ~mem_pattern adtype p_ut in
   match (ut, adtype) with
   | UnsizedType.UArray t, _ ->
-      Types.std_vector (lower_possibly_var_decl adtype t mem_pattern)
+      Types.std_vector
+        (lower_possibly_var_decl adtype t mem_pattern, mem_pattern)
   | ( ( UMatrix | UVector | URowVector | UComplexRowVector | UComplexVector
       | UComplexMatrix )
     , _ ) ->
       var_decl ut
-  | (UReal | UInt | UComplex), _ -> lower_unsizedtype_local adtype ut
+  | (UReal | UInt | UComplex), _ ->
+      lower_unsizedtype_local ~mem_pattern adtype ut
   | UTuple t_lst, TupleAD ads ->
       Tuple
         (List.map2_exn
@@ -276,7 +280,7 @@ and lower_misc_special_math_app (f : string) (mem_pattern : Mem_pattern.t)
         (fun _ ->
           Exprs.fun_call "stan::math::get_lp" [Var "lp__"; Var "lp_accum__"] )
   | "rep_matrix" | "rep_vector" | "rep_row_vector" | "append_row" | "append_col"
-    when mem_pattern = Mem_pattern.SoA -> (
+    when mem_pattern = Mem_pattern.SoA || mem_pattern = OpenCL -> (
       let is_autodiffable Expr.Fixed.{meta= Expr.Typed.Meta.{adlevel; _}; _} =
         adlevel = UnsizedType.AutoDiffable in
       match ret_type with
@@ -527,7 +531,7 @@ and lower_expr ?(promote_reals = false)
       if promote_reals then
         (* this can be important for e.g. templated function calls
            where we might generate an incorrect specification for int *)
-        static_cast Cpp.Double (lower_expr expr)
+        static_cast (Cpp.Double AoS) (lower_expr expr)
       else lower_expr expr
   | Promotion (expr, UComplex, DataOnly) when is_scalar expr ->
       (* this is in principle a little better than promote_scalar since it is constexpr *)
@@ -577,7 +581,7 @@ and lower_expr ?(promote_reals = false)
     | _ -> lower_indexed e idx (Fmt.to_to_string Expr.Typed.pp e) )
   | TupleProjection (t, ix) ->
       templated_fun_call "std::get"
-        [TypeLiteral (string_of_int (ix - 1))]
+        [TypeLiteral (string_of_int (ix - 1), Mem_pattern.AoS)]
         [lower_expr t]
 
 and lower_exprs ?(promote_reals = false) =
@@ -656,10 +660,10 @@ module Testing = struct
 
   let%expect_test "pp_expr12" =
     printf "%s\n"
-      (Fmt.str "%a" Cpp.Printing.pp_expr (vector_literal Cpp.Double [])) ;
+      (Fmt.str "%a" Cpp.Printing.pp_expr (vector_literal (Cpp.Double AoS) [])) ;
     printf "%s"
       (Fmt.str "%a" Cpp.Printing.pp_expr
-         (vector_literal ~column:true Cpp.Double []) ) ;
+         (vector_literal ~column:true (Cpp.Double AoS) []) ) ;
     [%expect
       {|
       Eigen::Matrix<double,1,-1>(0)
diff --git a/src/stan_math_backend/Lower_functions.ml b/src/stan_math_backend/Lower_functions.ml
index 412d40723..5507ab7d7 100644
--- a/src/stan_math_backend/Lower_functions.ml
+++ b/src/stan_math_backend/Lower_functions.ml
@@ -6,16 +6,16 @@ open Cpp
 
 let rec lower_type_eigen_expr (t : UnsizedType.t) (inner_type : type_) : type_ =
   match t with
-  | UInt -> Int
+  | UInt -> Int AoS
   | UReal | UMatrix | URowVector | UVector | UComplexVector | UComplexMatrix
    |UComplexRowVector | UTuple _ ->
       inner_type
   | UComplex -> Types.complex inner_type
   | UArray t when UnsizedType.contains_tuple t ->
-      StdVector (lower_type_eigen_expr t inner_type)
+      StdVector (lower_type_eigen_expr t inner_type, AoS)
   | UArray t ->
       (* Expressions are not accepted for arrays of Eigen::Matrix *)
-      StdVector (lower_type t inner_type)
+      StdVector (lower_type t inner_type, AoS)
   | UMathLibraryFunction | UFun _ ->
       Common.FatalError.fatal_error_msg
         [%message "Function types not implemented"]
@@ -151,14 +151,14 @@ let%expect_test "arg types tuple template" =
 
 let lower_promoted_scalar args =
   match args with
-  | [] -> Double
+  | [] -> Double AoS
   | _ ->
       let rec promote_args_chunked args =
         let chunk_till_empty list_tail =
           match list_tail with [] -> [] | _ -> [promote_args_chunked list_tail]
         in
         match args with
-        | [] -> Double
+        | [] -> Double AoS
         | hd :: list_tail ->
             TypeTrait ("stan::promote_args_t", hd @ chunk_till_empty list_tail)
       in
@@ -239,7 +239,7 @@ let lower_args extra_templates extra args variadic =
   let arg_strs =
     args
     @ mk_extra_args extra_templates extra
-    @ [(Pointer (TypeLiteral "std::ostream"), "pstream__")]
+    @ [(Pointer (TypeLiteral ("std::ostream", AoS)), "pstream__")]
     @ variadic_args in
   arg_strs
 
@@ -382,17 +382,19 @@ let lower_standalone_fun_def namespace_fun
   let all_args =
     args
     @ mk_extra_args extra_templates extra
-    @ [(Pointer (TypeLiteral "std::ostream"), "pstream__ = nullptr")] in
+    @ [(Pointer (TypeLiteral ("std::ostream", AoS)), "pstream__ = nullptr")]
+  in
   let mark_function_comment = GlobalComment "[[stan::function]]" in
   let return_type, return_stmt =
     match fdrt with
     | Void -> (Void, fun e -> Expression e)
-    | ReturnType ut -> (lower_type ut Double, fun e -> Return (Some e)) in
+    | ReturnType ut -> (lower_type ut (Double AoS), fun e -> Return (Some e))
+  in
   let fn_sig = make_fun_defn ~name:fdname ~return_type ~args:all_args in
   let internal_fname = namespace_fun ^ "::" ^ fdname in
   let template =
     match fdsuffix with
-    | FnLpdf _ | FnTarget -> [TypeLiteral "false"]
+    | FnLpdf _ | FnTarget -> [TypeLiteral ("false", AoS)]
     | FnRng | FnPlain -> [] in
   let call_args =
     List.map ~f:(fun (_, name, _) -> name) fdargs @ extra @ ["pstream__"]
diff --git a/src/stan_math_backend/Lower_program.ml b/src/stan_math_backend/Lower_program.ml
index f675bd519..faf496fa8 100644
--- a/src/stan_math_backend/Lower_program.ml
+++ b/src/stan_math_backend/Lower_program.ml
@@ -22,7 +22,8 @@ let get_unconstrained_param_st lst =
 let gen_function__ prog_name fname =
   [ VariableDefn
       (make_variable_defn ~static:true ~constexpr:true
-         ~type_:(Const (Pointer (TypeLiteral "char"))) ~name:"function__"
+         ~type_:(Const (Pointer (TypeLiteral ("char", AoS))))
+         ~name:"function__"
          ~init:
            (Assignment
               (Exprs.literal_string (prog_name ^ "_namespace::" ^ fname)) )
@@ -38,17 +39,16 @@ let includes = Preprocessor (Include "stan/model/model_header.hpp")
   @param vident name of the private member.
   @param ut The unsized type to print.
  *)
-let lower_data_decl (vident, ut) : defn =
+let lower_data_decl (vident, (st : 'a SizedType.t)) : defn =
   let data_vident =
-    if UnsizedType.is_eigen_type ut && not (Transform_Mir.is_opencl_var vident)
-    then vident ^ "_data__"
-    else vident in
+    if SizedType.is_eigen_type st then vident ^ "_data__" else vident in
   GlobalVariableDefn
-    (lower_unsized_decl data_vident ut
-       (UnsizedType.fill_adtype_for_type DataOnly ut) )
+    (lower_unsized_decl data_vident (SizedType.to_unsized st)
+       (UnsizedType.fill_adtype_for_type DataOnly (SizedType.to_unsized st))
+       (SizedType.get_mem_pattern st) )
 
 (** Create maps of Eigen types*)
-let lower_map_decl (vident, ut) : defn =
+let lower_map_decl (vident, (st : 'a SizedType.t)) : defn =
   let eigen_map t ndims =
     GlobalVariableDefn
       (make_variable_defn
@@ -59,6 +59,7 @@ let lower_map_decl (vident, ut) : defn =
               (Literal "nullptr" :: List.init ndims ~f:(fun _ -> Literal "0"))
            )
          () ) in
+  let ut = SizedType.to_unsized st in
   let scalar = local_scalar ut DataOnly in
   let open Types in
   match ut with
@@ -76,8 +77,9 @@ let lower_map_decl (vident, ut) : defn =
 
 let rec top_level_decls Stmt.Fixed.{pattern; _} =
   match pattern with
-  | Decl d when d.decl_id <> "pos__" ->
-      [(d.decl_id, Type.to_unsized d.decl_type)]
+  | Decl {decl_id; decl_type= Type.Sized decl_type_st; _}
+    when decl_id <> "pos__" ->
+      [(decl_id, decl_type_st)]
   | SList stmts -> List.concat_map ~f:top_level_decls stmts
   | _ -> []
 
@@ -85,9 +87,8 @@ let rec top_level_decls Stmt.Fixed.{pattern; _} =
 let lower_model_private {Program.prepare_data; _} =
   let data_decls = List.concat_map ~f:top_level_decls prepare_data in
   (*Filter out Any data that is not an Eigen matrix*)
-  let get_eigen_map (name, ut) =
-    UnsizedType.is_eigen_type ut && not (Transform_Mir.is_opencl_var name) in
-  let eigen_map_decls = (List.filter ~f:get_eigen_map) data_decls in
+  let get_eigen_map (_, (st : 'a SizedType.t)) = SizedType.is_eigen_type st in
+  let eigen_map_decls = List.filter ~f:get_eigen_map data_decls in
   List.map ~f:lower_data_decl data_decls
   @ List.map ~f:lower_map_decl eigen_map_decls
 
@@ -102,8 +103,8 @@ let rec validate_dims ~stage name st =
   else
     let vector args =
       let cast x = Exprs.static_cast Types.size_t (lower_expr x) in
-      InitializerExpr (Types.std_vector Types.size_t, List.map ~f:cast args)
-    in
+      InitializerExpr
+        (Types.std_vector (Types.size_t, AoS), List.map ~f:cast args) in
     let open Expression_syntax in
     let context = Var "context__" in
     let validate =
@@ -120,7 +121,11 @@ let gen_assign_data decl_id st =
   let lower_placement_new decl_id st =
     let open Expression_syntax in
     match st with
-    | SizedType.SVector (_, d)
+    | SizedType.SVector (Mem_pattern.OpenCL, _)
+     |SRowVector (OpenCL, _)
+     |SMatrix (OpenCL, _, _) ->
+        []
+    | SVector (_, d)
      |SRowVector (_, d)
      |SComplexVector d
      |SComplexRowVector d ->
@@ -140,28 +145,48 @@ let gen_assign_data decl_id st =
     | _ -> [] in
   let underlying_var decl_id st =
     match st with
+    | SizedType.SVector (Mem_pattern.OpenCL, _)
+     |SRowVector (OpenCL, _)
+     |SMatrix (OpenCL, _, _) ->
+        Var decl_id
     | SizedType.SVector _ | SRowVector _ | SMatrix _ | SComplexVector _
      |SComplexRowVector _ | SComplexMatrix _ ->
         Var (decl_id ^ "_data__")
-    | SInt | SReal | SComplex | SArray _ | STuple _ -> Var decl_id in
-  Expression
-    (Assign
-       ( underlying_var decl_id st
-       , initialize_value st
-           (UnsizedType.fill_adtype_for_type UnsizedType.DataOnly
-              (SizedType.to_unsized st) ) ) )
-  :: lower_placement_new decl_id st
+    | SInt _ | SReal _ | SComplex | SArray _ | STuple _ -> Var decl_id in
+  match st with
+  | (SizedType.SVector (mem, _) | SRowVector (mem, _) | SMatrix (mem, _, _))
+    when Mem_pattern.is_opencl mem ->
+      [ Expression
+          (Assign
+             ( underlying_var decl_id st (*9 here for _opencl__*)
+             , FunCall
+                 ( "stan::math::to_matrix_cl"
+                 , []
+                 , [ Var
+                       (String.sub decl_id ~pos:0
+                          ~len:(String.length decl_id - 9) ) ] ) ) ) ]
+  | _ ->
+      (* I think we don't want to initialize to NA for OpenCL types?*)
+      Expression
+        (Assign
+           ( underlying_var decl_id st
+           , initialize_value st
+               (UnsizedType.fill_adtype_for_type UnsizedType.DataOnly
+                  (SizedType.to_unsized st) ) ) )
+      :: lower_placement_new decl_id st
 
 let lower_constructor
     {Program.prog_name; input_vars; prepare_data; output_vars; _} =
   let args =
-    [ (Ref (TypeLiteral "stan::io::var_context"), "context__")
-    ; (TypeLiteral "unsigned int", "random_seed__ = 0")
-    ; (Pointer (TypeLiteral "std::ostream"), "pstream__ = nullptr") ] in
+    [ (Ref (TypeLiteral ("stan::io::var_context", AoS)), "context__")
+    ; (TypeLiteral ("unsigned int", AoS), "random_seed__ = 0")
+    ; (Pointer (TypeLiteral ("std::ostream", AoS)), "pstream__ = nullptr") ]
+  in
   let preamble =
-    [ Decls.current_statement; Using ("local_scalar_t__", Some Double)
+    [ Decls.current_statement; Using ("local_scalar_t__", Some (Double AoS))
     ; VariableDefn
-        (make_variable_defn ~type_:(TypeLiteral "boost::ecuyer1988")
+        (make_variable_defn
+           ~type_:(TypeLiteral ("boost::ecuyer1988", AoS))
            ~name:"base_rng__"
            ~init:
              (Assignment
@@ -205,7 +230,8 @@ let gen_log_prob Program.{prog_name; log_prob; reverse_mode_log_prob; _} =
   let args : (type_ * string) list =
     [ (Ref (TemplateType "VecR"), "params_r__")
     ; (Ref (TemplateType "VecI"), "params_i__")
-    ; (Pointer (TypeLiteral "std::ostream"), "pstream__ = nullptr") ] in
+    ; (Pointer (TypeLiteral ("std::ostream", AoS)), "pstream__ = nullptr") ]
+  in
   (*
      NOTE: There is a bug in clang-6.0 where removing this T__ causes the
       reverse mode autodiff path to fail with an initializer list error
@@ -213,7 +239,7 @@ let gen_log_prob Program.{prog_name; log_prob; reverse_mode_log_prob; _} =
       more into why this is happening
       *)
   let intro =
-    let t__ = TypeLiteral "T__" in
+    let t__ = TypeLiteral ("T__", AoS) in
     [ Using
         ("T__", Some (TypeTrait ("stan::scalar_type_t", [TemplateType "VecR"])))
     ; Using ("local_scalar_t__", Some t__)
@@ -266,19 +292,20 @@ let gen_write_array {Program.prog_name; generate_quantities; _} =
     ; (Ref (TemplateType "VecVar"), "vars__")
     ; (Const Types.bool, "emit_transformed_parameters__ = true")
     ; (Const Types.bool, "emit_generated_quantities__ = true")
-    ; (Pointer (TypeLiteral "std::ostream"), "pstream__ = nullptr") ] in
+    ; (Pointer (TypeLiteral ("std::ostream", AoS)), "pstream__ = nullptr") ]
+  in
   let intro =
-    [ Using ("local_scalar_t__", Some Double); Decls.serializer_in
+    [ Using ("local_scalar_t__", Some (Double AoS)); Decls.serializer_in
     ; Decls.serializer_out
     ; VariableDefn
         (make_variable_defn ~static:true ~constexpr:true ~type_:Types.bool
            ~name:"propto__" ~init:(Assignment (Literal "true")) () ) ]
     @ Stmts.unused "propto__"
     @ VariableDefn
-        (make_variable_defn ~type_:Double ~name:"lp__"
+        (make_variable_defn ~type_:(Double AoS) ~name:"lp__"
            ~init:(Assignment (Literal "0.0")) () )
       :: Stmts.unused "lp__"
-    @ [Decls.current_statement; Decls.lp_accum Double]
+    @ [Decls.current_statement; Decls.lp_accum (Double AoS)]
     @ Decls.dummy_var
     @ VariableDefn
         (make_variable_defn ~constexpr:true ~type_:Types.bool ~name:"jacobian__"
@@ -297,11 +324,12 @@ let gen_transform_inits_impl {Program.transform_inits; output_vars; _} =
   let templates =
     [Typename "VecVar"; Require ("stan::require_vector_t", ["VecVar"])] in
   let args =
-    [ (Types.const_ref (TypeLiteral "stan::io::var_context"), "context__")
+    [ (Types.const_ref (TypeLiteral ("stan::io::var_context", AoS)), "context__")
     ; (Ref (TemplateType "VecVar"), "vars__")
-    ; (Pointer (TypeLiteral "std::ostream"), "pstream__ = nullptr") ] in
+    ; (Pointer (TypeLiteral ("std::ostream", AoS)), "pstream__ = nullptr") ]
+  in
   let intro =
-    [ Using ("local_scalar_t__", Some Double); Decls.serializer_out
+    [ Using ("local_scalar_t__", Some (Double AoS)); Decls.serializer_out
     ; Decls.current_statement ]
     @ Decls.dummy_var in
   let validate_params
@@ -335,9 +363,10 @@ let gen_unconstrain_array_impl {Program.unconstrain_array; _} =
     [ (Types.const_ref (TemplateType "VecVar"), "params_r__")
     ; (Types.const_ref (TemplateType "VecI"), "params_i__")
     ; (Ref (TemplateType "VecVar"), "vars__")
-    ; (Pointer (TypeLiteral "std::ostream"), "pstream__ = nullptr") ] in
+    ; (Pointer (TypeLiteral ("std::ostream", AoS)), "pstream__ = nullptr") ]
+  in
   let intro =
-    [ Using ("local_scalar_t__", Some Double); Decls.serializer_in
+    [ Using ("local_scalar_t__", Some (Double AoS)); Decls.serializer_in
     ; Decls.serializer_out; Decls.current_statement ]
     @ Decls.dummy_var in
   FunDef
@@ -374,7 +403,7 @@ let gen_get_param_names {Program.output_vars; _} =
       | id, _, {out_block= GeneratedQuantities; out_constrained_st= st; _} ->
           `Trd (param_to_names id st) ) in
   let args =
-    [ (Ref (Types.std_vector Types.string), "names__")
+    [ (Ref (Types.std_vector (Types.string, AoS)), "names__")
     ; (Const Types.bool, "emit_transformed_parameters__ = true")
     ; (Const Types.bool, "emit_generated_quantities__ = true") ] in
   let names = Var "names__" in
@@ -387,14 +416,14 @@ let gen_get_param_names {Program.output_vars; _} =
           ( Var "emit_transformed_parameters__"
           , Stmts.block
               (gen_extend_vector names
-                 (Types.std_vector Types.string)
+                 (Types.std_vector (Types.string, AoS))
                  (List.concat tparams) )
           , None )
       ; IfElse
           ( Var "emit_generated_quantities__"
           , Stmts.block
               (gen_extend_vector names
-                 (Types.std_vector Types.string)
+                 (Types.std_vector (Types.string, AoS))
                  (List.concat gqs) )
           , None ) ] in
   FunDef
@@ -429,8 +458,8 @@ let gen_get_dims {Program.output_vars; _} =
         ->
           `Trd (pack st) ) in
   let args =
-    [ (Ref (Types.std_vector (Types.std_vector Types.size_t)), "dimss__")
-    ; (Const Types.bool, "emit_transformed_parameters__ = true")
+    [ ( Ref (Types.std_vector (Types.std_vector (Types.size_t, AoS), AoS))
+      , "dimss__" ); (Const Types.bool, "emit_transformed_parameters__ = true")
     ; (Const Types.bool, "emit_generated_quantities__ = true") ] in
   let dimss = Var "dimss__" in
   let body =
@@ -438,20 +467,20 @@ let gen_get_dims {Program.output_vars; _} =
         (Assign
            ( dimss
            , Exprs.std_vector_init_expr
-               (Types.std_vector Types.size_t)
+               (Types.std_vector (Types.size_t, AoS))
                (List.concat params) ) )
     ; IfElse
         ( Var "emit_transformed_parameters__"
         , Stmts.block
             (gen_extend_vector dimss
-               (Types.std_vector (Types.std_vector Types.size_t))
+               (Types.std_vector (Types.std_vector (Types.size_t, AoS), AoS))
                (List.concat tparams) )
         , None )
     ; IfElse
         ( Var "emit_generated_quantities__"
         , Stmts.block
             (gen_extend_vector dimss
-               (Types.std_vector (Types.std_vector Types.size_t))
+               (Types.std_vector (Types.std_vector (Types.size_t, AoS), AoS))
                (List.concat gqs) )
         , None ) ] in
   FunDef
@@ -519,7 +548,7 @@ let rec gen_param_names ?(outer_idcs = []) (decl_id, st) =
 
 let gen_param_names_fn name (paramvars, tparamvars, gqvars) =
   let args =
-    [ (Ref (Types.std_vector Types.string), "param_names__")
+    [ (Ref (Types.std_vector (Types.string, AoS)), "param_names__")
     ; (Types.bool, "emit_transformed_parameters__ = true")
     ; (Types.bool, "emit_generated_quantities__ = true") ] in
   let body =
@@ -593,7 +622,8 @@ let gen_constrained_types {Program.output_vars; _} =
 
 (** The generic method overloads needed in the model class. *)
 let gen_overloads {Program.output_vars; _} =
-  let pstream = (Pointer (TypeLiteral "std::ostream"), "pstream = nullptr") in
+  let pstream =
+    (Pointer (TypeLiteral ("std::ostream", AoS)), "pstream = nullptr") in
   let write_arrays =
     let open Expression_syntax in
     let templates_init = ([[Typename "RNG"]], false) in
@@ -656,18 +686,19 @@ let gen_overloads {Program.output_vars; _} =
            ~name:"write_array"
            ~args:
              ( [ (Ref (TemplateType "RNG"), "base_rng")
-               ; (Ref (Types.vector Double), "params_r")
-               ; (Ref (Types.vector Double), "vars") ]
+               ; (Ref (Types.vector (Double AoS)), "params_r")
+               ; (Ref (Types.vector (Double AoS)), "vars") ]
              @ emit_flags true @ [pstream] )
            ~body:
              ( sizes
              @ [ VariableDefn
-                   (make_variable_defn ~type_:(Types.std_vector Int)
+                   (make_variable_defn
+                      ~type_:(Types.std_vector (Int AoS, AoS))
                       ~name:"params_i" () )
                ; Expression
                    (Assign
                       ( Var "vars"
-                      , Types.vector Double
+                      , Types.vector (Double AoS)
                         |::? ("Constant", [Var "num_to_write"; Exprs.quiet_NaN])
                       ) ); call_impl ] )
            ~cv_qualifiers:[Const] () )
@@ -676,9 +707,9 @@ let gen_overloads {Program.output_vars; _} =
            ~name:"write_array"
            ~args:
              ( [ (Ref (TemplateType "RNG"), "base_rng")
-               ; (Ref (Types.std_vector Double), "params_r")
-               ; (Ref (Types.std_vector Int), "params_i")
-               ; (Ref (Types.std_vector Double), "vars") ]
+               ; (Ref (Types.std_vector (Double AoS, AoS)), "params_r")
+               ; (Ref (Types.std_vector (Int AoS, AoS)), "params_i")
+               ; (Ref (Types.std_vector (Double AoS, AoS)), "vars") ]
              @ emit_flags false @ [pstream] )
            ~body:
              ( sizes
@@ -686,7 +717,7 @@ let gen_overloads {Program.output_vars; _} =
                    (Assign
                       ( Var "vars"
                       , Constructor
-                          ( Types.std_vector Double
+                          ( Types.std_vector (Double AoS, AoS)
                           , [Var "num_to_write"; Exprs.quiet_NaN] ) ) )
                ; call_impl ] )
            ~cv_qualifiers:[Const] () ) ] in
@@ -705,32 +736,35 @@ let gen_overloads {Program.output_vars; _} =
            ~args:[(Ref (Types.vector (TemplateType "T_")), "params_r"); pstream]
            ~body:
              [ VariableDefn
-                 (make_variable_defn ~type_:(Types.vector Int) ~name:"params_i"
-                    () ); call_impl ]
+                 (make_variable_defn ~type_:(Types.vector (Int AoS))
+                    ~name:"params_i" () ); call_impl ]
            ~cv_qualifiers:[Const] () )
     ; FunDef
         (make_fun_defn ~templates_init ~inline:true
            ~return_type:(TemplateType "T_") ~name:"log_prob"
            ~args:
-             [ (Ref (Types.std_vector (TemplateType "T_")), "params_r")
-             ; (Ref (Types.std_vector Int), "params_i"); pstream ]
+             [ (Ref (Types.std_vector (TemplateType "T_", AoS)), "params_r")
+             ; (Ref (Types.std_vector (Int AoS, AoS)), "params_i"); pstream ]
            ~body:[call_impl] ~cv_qualifiers:[Const] () ) ] in
   let transform_inits =
     [ FunDef
         (make_fun_defn ~inline:true ~return_type:Void ~name:"transform_inits"
            ~args:
-             [ (Types.const_ref (TypeLiteral "stan::io::var_context"), "context")
-             ; (Ref (Types.vector Double), "params_r"); pstream ]
+             [ ( Types.const_ref (TypeLiteral ("stan::io::var_context", AoS))
+               , "context" ); (Ref (Types.vector (Double AoS)), "params_r")
+             ; pstream ]
            ~body:
              [ VariableDefn
-                 (make_variable_defn ~type_:(Types.std_vector Double)
+                 (make_variable_defn
+                    ~type_:(Types.std_vector (Double AoS, AoS))
                     ~name:"params_r_vec"
                     ~init:
                       (Construction
                          [Exprs.method_call (Var "params_r") "size" [] []] )
                     () )
              ; VariableDefn
-                 (make_variable_defn ~type_:(Types.std_vector Int)
+                 (make_variable_defn
+                    ~type_:(Types.std_vector (Int AoS, AoS))
                     ~name:"params_i" () )
              ; Expression
                  (Exprs.fun_call "transform_inits"
@@ -740,17 +774,18 @@ let gen_overloads {Program.output_vars; _} =
                  (Assign
                     ( Var "params_r"
                     , Constructor
-                        ( TypeTrait ("Eigen::Map", [Types.vector Double])
+                        ( TypeTrait ("Eigen::Map", [Types.vector (Double AoS)])
                         , let params_r_vec = Var "params_r_vec" in
                           let open Expression_syntax in
                           [params_r_vec.@!("data"); params_r_vec.@!("size")] )
                     ) ) ]
            ~cv_qualifiers:[Const; Final] () )
     ; (let args =
-         [ (Types.const_ref (TypeLiteral "stan::io::var_context"), "context")
-         ; (Ref (Types.std_vector Int), "params_i")
-         ; (Ref (Types.std_vector Double), "vars")
-         ; (Pointer (TypeLiteral "std::ostream"), "pstream__ = nullptr") ] in
+         [ ( Types.const_ref (TypeLiteral ("stan::io::var_context", AoS))
+           , "context" ); (Ref (Types.std_vector (Int AoS, AoS)), "params_i")
+         ; (Ref (Types.std_vector (Double AoS, AoS)), "vars")
+         ; (Pointer (TypeLiteral ("std::ostream", AoS)), "pstream__ = nullptr")
+         ] in
        let body =
          let open Expression_syntax in
          [ Expression (Var "vars").@?(("resize", [Var "num_params_r__"]))
@@ -770,36 +805,39 @@ let gen_overloads {Program.output_vars; _} =
     [ FunDef
         (make_fun_defn ~inline:true ~return_type:Void ~name:"unconstrain_array"
            ~args:
-             [ (Types.const_ref (Types.std_vector Double), "params_constrained")
-             ; (Ref (Types.std_vector Double), "params_unconstrained"); pstream
-             ]
+             [ ( Types.const_ref (Types.std_vector (Double AoS, AoS))
+               , "params_constrained" )
+             ; (Ref (Types.std_vector (Double AoS, AoS)), "params_unconstrained")
+             ; pstream ]
            ~body:
              [ VariableDefn
                  (make_variable_defn
-                    ~type_:Types.(Const (std_vector Int))
+                    ~type_:Types.(Const (std_vector (Int AoS, AoS)))
                     ~name:"params_i" () )
              ; Expression
                  (Assign
                     ( Var "params_unconstrained"
                     , Constructor
-                        ( Types.std_vector Double
+                        ( Types.std_vector (Double AoS, AoS)
                         , [Var "num_params_r__"; Exprs.quiet_NaN] ) ) )
              ; call_impl ]
            ~cv_qualifiers:[Const (*; Final*)] () )
     ; FunDef
         (make_fun_defn ~inline:true ~return_type:Void ~name:"unconstrain_array"
            ~args:
-             [ (Types.const_ref (Types.vector Double), "params_constrained")
-             ; (Ref (Types.vector Double), "params_unconstrained"); pstream ]
+             [ ( Types.const_ref (Types.vector (Double AoS))
+               , "params_constrained" )
+             ; (Ref (Types.vector (Double AoS)), "params_unconstrained")
+             ; pstream ]
            ~body:
              [ VariableDefn
                  (make_variable_defn
-                    ~type_:Types.(Const (std_vector Int))
+                    ~type_:Types.(Const (std_vector (Int AoS, AoS)))
                     ~name:"params_i" () )
              ; Expression
                  (Assign
                     ( Var "params_unconstrained"
-                    , Types.vector Double
+                    , Types.vector (Double AoS)
                       |::? ("Constant", [Var "num_params_r__"; Exprs.quiet_NaN])
                     ) ); call_impl ]
            ~cv_qualifiers:[Const (*; Final*)] () ) ] in
@@ -825,7 +863,7 @@ let model_public_basics name =
          () )
   ; FunDef
       (make_fun_defn ~inline:true
-         ~return_type:(Types.std_vector Types.string)
+         ~return_type:(Types.std_vector (Types.string, AoS))
          ~name:"model_compile_info"
          ~body:
            [ Return
@@ -842,7 +880,8 @@ let lower_model ({Program.prog_name; _} as p) =
   let constructor = lower_constructor p in
   Class
     (make_class_defn ~name:prog_name ~final:true
-       ~public_base:(TypeTrait ("model_base_crtp", [TypeLiteral prog_name]))
+       ~public_base:
+         (TypeTrait ("model_base_crtp", [TypeLiteral (prog_name, AoS)]))
        ~private_members ~public_members ~constructor () )
 
 (** Create the model's namespace. *)
@@ -856,31 +895,33 @@ let usings =
 let new_model_boilerplate prog_name =
   let new_model =
     let args =
-      [ (Ref (TypeLiteral "stan::io::var_context"), "data_context")
-      ; (TypeLiteral "unsigned int", "seed")
-      ; (Pointer (TypeLiteral "std::ostream"), "msg_stream") ] in
+      [ (Ref (TypeLiteral ("stan::io::var_context", AoS)), "data_context")
+      ; (TypeLiteral ("unsigned int", AoS), "seed")
+      ; (Pointer (TypeLiteral ("std::ostream", AoS)), "msg_stream") ] in
     let body =
       [ VariableDefn
-          (make_variable_defn ~type_:(Pointer (TypeLiteral "stan_model"))
+          (make_variable_defn
+             ~type_:(Pointer (TypeLiteral ("stan_model", AoS)))
              ~name:"m"
              ~init:
                (Assignment
                   (AllocNew
-                     ( TypeLiteral "stan_model"
+                     ( TypeLiteral ("stan_model", AoS)
                      , [Var "data_context"; Var "seed"; Var "msg_stream"] ) ) )
              () ); Return (Some (Literal "*m")) ] in
     FunDef
       (make_fun_defn ~name:"new_model"
-         ~return_type:(Ref (TypeLiteral "stan::model::model_base")) ~args ~body
-         () ) in
+         ~return_type:(Ref (TypeLiteral ("stan::model::model_base", AoS)))
+         ~args ~body () ) in
   let profile_data =
     FunDef
       (make_fun_defn ~name:"get_stan_profile_data"
-         ~return_type:(Ref (TypeLiteral "stan::math::profile_map"))
+         ~return_type:(Ref (TypeLiteral ("stan::math::profile_map", AoS)))
          ~body:[Return (Some (Literal (prog_name ^ "_namespace::profiles__")))]
          () ) in
   [ GlobalUsing
-      ("stan_model", Some (TypeLiteral (prog_name ^ "_namespace::" ^ prog_name)))
+      ( "stan_model"
+      , Some (TypeLiteral (prog_name ^ "_namespace::" ^ prog_name, AoS)) )
   ; Preprocessor
       (IfNDef ("USING_R", [GlobalComment "Boilerplate"; new_model; profile_data])
       ) ]
@@ -945,7 +986,7 @@ module Testing = struct
 
   let%expect_test "complex names" =
     gen_param_names
-      ("foo", SizedType.SArray (SComplex, Middle.Expr.Helpers.variable "N"))
+      ("foo", SizedType.SArray (AoS, SComplex, Middle.Expr.Helpers.variable "N"))
     |> str "@[<v>%a" (list ~sep:cut Cpp.Printing.pp_stmt)
     |> print_endline ;
     [%expect
@@ -961,7 +1002,9 @@ module Testing = struct
     gen_param_names
       ( "tuple"
       , SizedType.(
-          STuple [SInt; SArray (SReal, Middle.Expr.Helpers.variable "nested")])
+          STuple
+            [ SInt AoS
+            ; SArray (AoS, SReal AoS, Middle.Expr.Helpers.variable "nested") ])
       )
     |> str "@[<v>%a" (list ~sep:cut Cpp.Printing.pp_stmt)
     |> print_endline ;
@@ -978,8 +1021,11 @@ module Testing = struct
       ( "arr_tuple"
       , SizedType.(
           SArray
-            ( STuple
-                [SInt; SArray (SReal, Middle.Expr.Helpers.variable "nested")]
+            ( AoS
+            , STuple
+                [ SInt AoS
+                ; SArray (AoS, SReal AoS, Middle.Expr.Helpers.variable "nested")
+                ]
             , Middle.Expr.Helpers.variable "N" )) )
     |> str "@[<v>%a" (list ~sep:cut Cpp.Printing.pp_stmt)
     |> print_endline ;
diff --git a/src/stan_math_backend/Lower_stmt.ml b/src/stan_math_backend/Lower_stmt.ml
index abdfdd82b..fb38a8168 100644
--- a/src/stan_math_backend/Lower_stmt.ml
+++ b/src/stan_math_backend/Lower_stmt.ml
@@ -40,8 +40,8 @@ let rec initialize_value st adtype =
     if adtype = UnsizedType.DataOnly then Exprs.quiet_NaN else Var "DUMMY_VAR__"
   in
   match (adtype, st) with
-  | UnsizedType.(DataOnly | AutoDiffable), SizedType.SInt -> Exprs.int_min
-  | (DataOnly | AutoDiffable), SReal -> init_nan
+  | UnsizedType.(DataOnly | AutoDiffable), SizedType.SInt _ -> Exprs.int_min
+  | (DataOnly | AutoDiffable), SReal _ -> init_nan
   | (DataOnly | AutoDiffable), SComplex ->
       let scalar = local_scalar (SizedType.to_unsized st) adtype in
       Constructor (Types.complex scalar, [init_nan; init_nan])
@@ -72,10 +72,22 @@ let rec initialize_value st adtype =
   | AutoDiffable, SMatrix (SoA, d1, d2) ->
       let typ = lower_possibly_var_decl adtype (SizedType.to_unsized st) SoA in
       Constructor (typ, [initialize_value (SMatrix (AoS, d1, d2)) DataOnly])
-  | DataOnly, SArray (t, d) ->
+  | AutoDiffable, SVector (OpenCL, size) ->
+      let typ =
+        lower_possibly_var_decl adtype (SizedType.to_unsized st) OpenCL in
+      Constructor (typ, [initialize_value (SVector (AoS, size)) DataOnly])
+  | AutoDiffable, SRowVector (OpenCL, size) ->
+      let typ =
+        lower_possibly_var_decl adtype (SizedType.to_unsized st) OpenCL in
+      Constructor (typ, [initialize_value (SRowVector (AoS, size)) DataOnly])
+  | AutoDiffable, SMatrix (OpenCL, d1, d2) ->
+      let typ =
+        lower_possibly_var_decl adtype (SizedType.to_unsized st) OpenCL in
+      Constructor (typ, [initialize_value (SMatrix (AoS, d1, d2)) DataOnly])
+  | DataOnly, SArray (_, t, d) ->
       let typ = lower_st st adtype in
       Constructor (typ, [lower_expr d; initialize_value t adtype])
-  | (AutoDiffable | TupleAD _), SArray (t, d) ->
+  | (AutoDiffable | TupleAD _), SArray (_, t, d) ->
       let typ =
         lower_possibly_var_decl adtype (SizedType.to_unsized st)
           (SizedType.get_mem_pattern t) in
@@ -94,26 +106,18 @@ let rec initialize_value st adtype =
 let lower_assign_sized st adtype initialize =
   if initialize then Some (initialize_value st adtype) else None
 
-let lower_unsized_decl name ut adtype =
-  let type_ =
-    match (Transform_Mir.is_opencl_var name, ut) with
-    | _, UnsizedType.(UInt | UReal) | false, _ ->
-        lower_unsizedtype_local adtype ut
-    | true, UArray UInt -> TypeLiteral "matrix_cl<int>"
-    | true, _ -> TypeLiteral "matrix_cl<double>" in
-  make_variable_defn ~type_ ~name ()
+let lower_unsized_decl name st adtype mem_pattern =
+  make_variable_defn
+    ~type_:(lower_unsizedtype_local ~mem_pattern adtype st)
+    ~name ()
 
-let lower_possibly_opencl_decl name st adtype =
+let lower_possibly_st_decl _ st adtype =
   let ut = SizedType.to_unsized st in
   let mem_pattern = SizedType.get_mem_pattern st in
-  match (Transform_Mir.is_opencl_var name, ut) with
-  | _, UnsizedType.(UInt | UReal) | false, _ ->
-      lower_possibly_var_decl adtype ut mem_pattern
-  | true, UArray UInt -> TypeLiteral "matrix_cl<int>"
-  | true, _ -> TypeLiteral "matrix_cl<double>"
+  lower_possibly_var_decl adtype ut mem_pattern
 
 let lower_sized_decl name st adtype initialize =
-  let type_ = lower_possibly_opencl_decl name st adtype in
+  let type_ = lower_possibly_st_decl name st adtype in
   let init =
     lower_assign_sized st adtype initialize
     |> Option.value_map ~default:Uninitialized ~f:(fun i -> Assignment i) in
@@ -122,19 +126,20 @@ let lower_sized_decl name st adtype initialize =
 let lower_decl vident pst adtype initialize =
   match pst with
   | Type.Sized st -> VariableDefn (lower_sized_decl vident st adtype initialize)
-  | Unsized ut -> VariableDefn (lower_unsized_decl vident ut adtype)
+  | Unsized ut ->
+      VariableDefn (lower_unsized_decl vident ut adtype Mem_pattern.AoS)
 
 let lower_profile name body =
   let profile =
     VariableDefn
       (make_variable_defn
-         ~type_:(TypeLiteral "stan::math::profile<local_scalar_t__>")
+         ~type_:(TypeLiteral ("stan::math::profile<local_scalar_t__>", AoS))
          ~name:"profile__"
          ~init:
            (Construction
               [ Var name
               ; Exprs.templated_fun_call "const_cast"
-                  [Ref (TypeLiteral "stan::math::profile_map")]
+                  [Ref (TypeLiteral ("stan::math::profile_map", AoS))]
                   [Var "profiles__"] ] )
          () ) in
   Stmts.block (profile :: body)
@@ -157,7 +162,7 @@ and lower_nonrange_lbase = function
   | Stmt.Fixed.Pattern.LVariable v -> Var v
   | LTupleProjection (lv, ix) ->
       Exprs.templated_fun_call "std::get"
-        [TypeLiteral (string_of_int (ix - 1))]
+        [TypeLiteral (string_of_int (ix - 1), AoS)]
         [lower_nonrange_lvalue lv]
 
 (* True if expr has a 'shallow' overlap with the lhs, for the purpose of checking if expr needs to be deep copied when it's assigned to the lhs.
@@ -251,7 +256,8 @@ let rec lower_statement Stmt.Fixed.{pattern; meta} : stmt list =
       let err_strm_name = "errmsg_stream__" in
       let stream_decl =
         VariableDefn
-          (make_variable_defn ~type_:(TypeLiteral "std::stringstream")
+          (make_variable_defn
+             ~type_:(TypeLiteral ("std::stringstream", AoS))
              ~name:err_strm_name () ) in
       let throw =
         Throw
@@ -320,7 +326,7 @@ module Testing = struct
     Fmt.str "@[<v>%a@]"
       (Fmt.option Cpp.Printing.pp_expr)
       (lower_assign_sized
-         (SArray (SArray (SMatrix (AoS, int 2, int 3), int 4), int 5))
+         (SArray (AoS, SArray (AoS, SMatrix (AoS, int 2, int 3), int 4), int 5))
          DataOnly false )
     |> print_endline ;
     [%expect {| |}]
@@ -330,7 +336,7 @@ module Testing = struct
     Fmt.str "@[<v>%a@]"
       (Fmt.option Cpp.Printing.pp_expr)
       (lower_assign_sized
-         (SArray (SArray (SMatrix (AoS, int 2, int 3), int 4), int 5))
+         (SArray (AoS, SArray (AoS, SMatrix (AoS, int 2, int 3), int 4), int 5))
          DataOnly true )
     |> print_endline ;
     [%expect
diff --git a/src/stan_math_backend/Numbering.ml b/src/stan_math_backend/Numbering.ml
index 245466332..6a1e925bd 100644
--- a/src/stan_math_backend/Numbering.ml
+++ b/src/stan_math_backend/Numbering.ml
@@ -70,7 +70,8 @@ let gen_globals ?printed_filename location_list =
   let location_count = List.length location_list in
   let arr_type = Types.const_char_array location_count in
   [ GlobalVariableDefn
-      (make_variable_defn ~type_:(TypeLiteral "stan::math::profile_map")
+      (make_variable_defn
+         ~type_:(TypeLiteral ("stan::math::profile_map", AoS))
          ~name:"profiles__" () )
   ; GlobalVariableDefn
       (make_variable_defn ~static:true ~constexpr:true ~type_:arr_type
diff --git a/src/stan_math_backend/Transform_Mir.ml b/src/stan_math_backend/Transform_Mir.ml
index aeaa57727..43d972397 100644
--- a/src/stan_math_backend/Transform_Mir.ml
+++ b/src/stan_math_backend/Transform_Mir.ml
@@ -3,8 +3,6 @@ open Core_kernel.Poly
 open Middle
 open Mangle
 
-let use_opencl = ref false
-
 let translate_funapps_and_kwrds e =
   let open Expr.Fixed in
   let f ({pattern; _} as expr) =
@@ -124,87 +122,13 @@ let break_eigen_cycles functions_block =
       fndef in
   List.map ~f:break_cycles functions_block
 
-let opencl_trigger_restrictions =
-  String.Map.of_alist_exn
-    [ ( "bernoulli_lpmf"
-      , [ [ (0, UnsizedType.DataOnly, UnsizedType.UArray UnsizedType.UInt)
-          ; (1, UnsizedType.DataOnly, UnsizedType.UReal) ] ] )
-    ; ( "bernoulli_logit_glm_lpmf"
-      , [ (* Array of conditions under which we do not want to move to OpenCL *)
-          [(1, UnsizedType.DataOnly, UnsizedType.URowVector)]
-          (* Argument 1 (0-based indexing) is a row vector *) ] )
-    ; ( "categorical_logit_glm_lpmf"
-      , [[(1, UnsizedType.DataOnly, UnsizedType.URowVector)]] )
-    ; ( "exponential_lpdf"
-      , [ [ (0, UnsizedType.AutoDiffable, UnsizedType.UVector)
-          ; (1, UnsizedType.DataOnly, UnsizedType.UReal) ] ] )
-    ; ( "neg_binomial_2_log_glm_lpmf"
-      , [[(1, UnsizedType.DataOnly, UnsizedType.URowVector)]] )
-    ; ( "normal_id_glm_lpdf"
-      , [[(1, UnsizedType.DataOnly, UnsizedType.URowVector)]] )
-    ; ( "ordered_logistic_glm_lpmf"
-      , [[(1, UnsizedType.DataOnly, UnsizedType.URowVector)]] )
-    ; ( "poisson_log_glm_lpmf"
-      , [[(1, UnsizedType.DataOnly, UnsizedType.URowVector)]] )
-    ; ("std_normal_lpdf", [[(0, UnsizedType.AutoDiffable, UnsizedType.UVector)]])
-    ; ( "uniform_lpdf"
-      , [ [ (0, UnsizedType.AutoDiffable, UnsizedType.UVector)
-          ; (1, UnsizedType.DataOnly, UnsizedType.UReal)
-          ; (1, UnsizedType.DataOnly, UnsizedType.UReal) ] ] ) ]
-
-let opencl_supported_functions =
-  [ "bernoulli_lpmf"; "bernoulli_logit_lpmf"; "bernoulli_logit_glm_lpmf"
-  ; "beta_lpdf"; "beta_proportion_lpdf"; "binomial_lpmf"
-  ; "categorical_logit_glm_lpmf"; "cauchy_lpdf"; "chi_square_lpdf"
-  ; "double_exponential_lpdf"; "exp_mod_normal_lpdf"; "exponential_lpdf"
-  ; "frechet_lpdf"; "gamma_lpdf"; "gumbel_lpdf"; "inv_chi_square_lpdf"
-  ; "inv_gamma_lpdf"; "logistic_lpdf"; "lognormal_lpdf"; "neg_binomial_lpmf"
-  ; "neg_binomial_2_lpmf"; "neg_binomial_2_log_lpmf"
-  ; "neg_binomial_2_log_glm_lpmf"; "normal_lpdf"; "normal_id_glm_lpdf"
-  ; "ordered_logistic_glm_lpmf"; "pareto_lpdf"; "pareto_type_2_lpdf"
-  ; "poisson_lpmf"; "poisson_log_lpmf"; "poisson_log_glm_lpmf"; "rayleigh_lpdf"
-  ; "scaled_inv_chi_square_lpdf"; "skew_normal_lpdf"; "std_normal_lpdf"
-  ; "student_t_lpdf"; "uniform_lpdf"; "weibull_lpdf" ]
-  |> String.Set.of_list
-
-let opencl_suffix = "_opencl__"
-
-let to_matrix_cl e =
+(*let to_matrix_cl e =
   Expr.Fixed.
     {e with pattern= FunApp (StanLib ("to_matrix_cl", FnPlain, AoS), [e])}
-
-let rec switch_expr_to_opencl available_cl_vars (Expr.Fixed.{pattern; _} as e) =
-  let is_avail = List.mem available_cl_vars ~equal:( = ) in
-  let to_cl (Expr.Fixed.{pattern; meta= {Expr.Typed.Meta.type_; _}} as e) =
-    match (pattern, type_) with
-    | Var s, _ when is_avail s ->
-        Expr.Fixed.{e with pattern= Var (s ^ opencl_suffix)}
-    | _, UnsizedType.(UInt | UReal) -> e
-    | _, _ -> to_matrix_cl e in
-  let check_type args (i, ad, t) =
-    let arg = List.nth_exn args i in
-    Expr.Typed.type_of arg = t
-    && UnsizedType.autodifftype_can_convert (Expr.Typed.adlevel_of arg) ad in
-  let is_restricted args = List.exists ~f:(List.for_all ~f:(check_type args)) in
-  let maybe_map_args args req_args =
-    match req_args with
-    | Some x when is_restricted args x -> args
-    | None | Some _ -> List.map args ~f:to_cl in
-  let is_fn_opencl_supported f = Set.mem opencl_supported_functions f in
-  match pattern with
-  | FunApp (StanLib (f, sfx, mem_pattern), args) when is_fn_opencl_supported f
-    ->
-      let trigger = Map.find opencl_trigger_restrictions f in
-      { e with
-        pattern=
-          FunApp (StanLib (f, sfx, mem_pattern), maybe_map_args args trigger) }
-  | x ->
-      { e with
-        pattern=
-          Expr.Fixed.Pattern.map (switch_expr_to_opencl available_cl_vars) x }
+*)
 
 let rec base_type = function
-  | SizedType.SArray (t, _) -> base_type t
+  | SizedType.SArray (_, t, _) -> base_type t
   | SVector _ | SRowVector _ | SMatrix _ -> UnsizedType.UReal
   | SComplexVector _ | SComplexRowVector _ | SComplexMatrix _ -> UComplex
   | x -> SizedType.to_unsized x
@@ -279,9 +203,9 @@ let rec var_context_read_inside_tuple enclosing_tuple_name origin_type
       (Stmt.Helpers.lvariable enclosing_tuple_pos, UInt, type_size)
     |> swrap in
   match st with
-  | SInt | SReal | SComplex ->
+  | SInt _ | SReal _ | SComplex ->
       [Assignment (decl_id_lval, unsized, origin) |> swrap; incr_tuple_pos]
-  | SArray ((SInt | SReal), _) ->
+  | SArray (_, (SInt _ | SReal _), _) ->
       [Assignment (decl_id_lval, flat_type, origin) |> swrap; incr_tuple_pos]
   | STuple subtypes ->
       let elements =
@@ -422,14 +346,14 @@ let rec var_context_read
       [{decl_var with pattern= Lit (Str, remove_prefix decl_id)}]
       Expr.Typed.Meta.{decl_var.meta with type_= flat_type} in
   match st with
-  | SInt | SReal | SComplex ->
+  | SInt _ | SReal _ | SComplex ->
       let e =
         { Expr.Fixed.pattern=
             Indexed
               (readfnapp decl_id flat_type, [Single Expr.Helpers.loop_bottom])
         ; meta= {decl_var.meta with type_= unsized} } in
       [Assignment (decl_id_lval, unsized, e) |> swrap]
-  | SArray ((SInt | SReal), _) ->
+  | SArray (_, (SInt _ | SReal _), _) ->
       [ Assignment (decl_id_lval, flat_type, readfnapp decl_id flat_type)
         |> swrap ]
   | STuple subtypes ->
@@ -603,8 +527,8 @@ let rec var_context_read
 let read_constrain_dims constrain_transform st =
   let rec constrain_get_dims st =
     match st with
-    | SizedType.SInt | SReal | SComplex | STuple _ -> []
-    | SArray (t, dim) -> dim :: constrain_get_dims t
+    | SizedType.SInt _ | SReal _ | SComplex | STuple _ -> []
+    | SArray (_, t, dim) -> dim :: constrain_get_dims t
     | SVector (_, d)
      |SRowVector (_, d)
      |SComplexVector d
@@ -960,33 +884,6 @@ let rec insert_before f to_insert = function
       if f hd then to_insert @ (hd :: tl)
       else hd :: insert_before f to_insert tl
 
-let is_opencl_var = String.is_suffix ~suffix:opencl_suffix
-
-let rec collect_vars_expr is_target accum Expr.Fixed.{pattern; _} =
-  Set.union accum
-    ( match pattern with
-    | Var s when is_target s -> String.Set.of_list [s]
-    | x ->
-        Expr.Fixed.Pattern.fold (collect_vars_expr is_target) String.Set.empty x
-    )
-
-let collect_opencl_vars s =
-  let rec go accum s =
-    Stmt.Fixed.(
-      Pattern.fold (collect_vars_expr is_opencl_var) go accum s.pattern) in
-  go String.Set.empty s
-
-let%expect_test "collect vars expr" =
-  let mkvar s = Expr.{Fixed.pattern= Var s; meta= Typed.Meta.empty} in
-  let args = List.map ~f:mkvar ["y"; "x_opencl__"; "z"; "w_opencl__"] in
-  let fnapp =
-    Expr.
-      { Fixed.pattern= FunApp (StanLib ("print", FnPlain, AoS), args)
-      ; meta= Typed.Meta.empty } in
-  Stmt.Fixed.{pattern= TargetPE fnapp; meta= Location_span.empty}
-  |> collect_opencl_vars |> String.Set.sexp_of_t |> print_s ;
-  [%expect {| (w_opencl__ x_opencl__) |}]
-
 let%expect_test "insert before" =
   let l = [1; 2; 3; 4; 5; 6] |> insert_before (( = ) 6) [999] in
   [%sexp (l : int list)] |> print_s ;
@@ -1026,7 +923,7 @@ let trans_prog (p : Program.Typed.t) =
     [ Stmt.Fixed.Pattern.Decl
         { decl_adtype= DataOnly
         ; decl_id= pos
-        ; decl_type= Sized SInt
+        ; decl_type= Sized (SInt AoS)
         ; initialize= true }
     ; Assignment (Stmt.Helpers.lvariable pos, UInt, Expr.Helpers.loop_bottom) ]
     |> List.map ~f:(fun pattern ->
@@ -1074,22 +971,6 @@ let trans_prog (p : Program.Typed.t) =
         , _ ) ->
         true
     | _ -> false in
-  let translate_to_open_cl stmts =
-    if !use_opencl then
-      let decl Stmt.Fixed.{pattern; _} =
-        match pattern with
-        | Decl {decl_type= Sized (SInt | SReal); _} -> None
-        | Decl {decl_id; _} -> Some decl_id
-        | _ -> None in
-      let data_var_idents = List.filter_map ~f:decl p.prepare_data in
-      let switch_expr = switch_expr_to_opencl data_var_idents in
-      let rec trans_stmt_to_opencl s =
-        Stmt.Fixed.
-          { s with
-            pattern= Pattern.map switch_expr trans_stmt_to_opencl s.pattern }
-      in
-      List.map stmts ~f:trans_stmt_to_opencl
-    else stmts in
   let tparam_writes_cond =
     match tparam_writes with
     | [] -> []
@@ -1106,68 +987,22 @@ let trans_prog (p : Program.Typed.t) =
   let generate_quantities =
     ( p.generate_quantities
     |> add_reads p.output_vars param_deserializer_read
-    |> translate_to_open_cl
     |> insert_before tparam_start param_writes
     |> insert_before gq_start tparam_writes_cond )
     @ gq_writes in
-  let log_prob =
-    p.log_prob
-    |> add_reads p.output_vars param_deserializer_read
-    |> translate_to_open_cl in
-  let opencl_vars =
-    String.Set.union_list
-      (List.concat_map
-         ~f:(List.map ~f:collect_opencl_vars)
-         [log_prob; generate_quantities] )
-    |> String.Set.to_list in
-  let maybe_add_opencl_events_clear =
-    let event_clear_stmt x =
-      Stmt.Fixed.
-        { pattern= NRFunApp (CompilerInternal (FnReadWriteEventsOpenCL x), [])
-        ; meta= Location_span.empty } in
-    List.map ~f:event_clear_stmt opencl_vars in
-  let to_matrix_cl_stmts =
-    List.concat_map opencl_vars ~f:(fun vident ->
-        let vident_sans_opencl =
-          String.chop_suffix_exn ~suffix:opencl_suffix vident in
-        let type_of_input_var =
-          match
-            List.find
-              ~f:(fun (s, _, _) -> String.equal s vident_sans_opencl)
-              p.input_vars
-          with
-          | Some (_, _, st) -> SizedType.to_unsized st
-          | None -> UnsizedType.UMatrix in
-        [ Stmt.Fixed.
-            { pattern=
-                Decl
-                  { decl_adtype= DataOnly
-                  ; decl_id= vident
-                  ; decl_type= Type.Unsized type_of_input_var
-                  ; initialize= true }
-            ; meta= Location_span.empty }
-        ; { pattern=
-              Assignment
-                ( Stmt.Helpers.lvariable vident
-                , type_of_input_var
-                , to_matrix_cl
-                    { pattern= Var vident_sans_opencl
-                    ; meta= Expr.Typed.Meta.empty } )
-          ; meta= Location_span.empty } ] ) in
+  let log_prob = p.log_prob |> add_reads p.output_vars param_deserializer_read in
   let p =
     let params =
       List.filter
         ~f:(fun (_, _, ov) -> ov.Program.out_block = Parameters)
         p.output_vars in
     { p with
-      log_prob=
-        log_prob @ maybe_add_opencl_events_clear
-        (*First initialization of reverse mode log prob *)
-    ; reverse_mode_log_prob= log_prob @ maybe_add_opencl_events_clear
+      log_prob (*First initialization of reverse mode log prob *)
+    ; reverse_mode_log_prob= log_prob
     ; prog_name= escape_name p.prog_name
     ; prepare_data=
-        (p.prepare_data |> add_reads p.input_vars var_context_read)
-        @ to_matrix_cl_stmts
+        p.prepare_data
+        |> add_reads p.input_vars var_context_read
         |> maybe_add_pos
     ; transform_inits=
         List.concat_map ~f:var_context_unconstrain_transform params
diff --git a/src/stan_math_backend/Transform_Mir.mli b/src/stan_math_backend/Transform_Mir.mli
index 421d40fb0..7139b87d4 100644
--- a/src/stan_math_backend/Transform_Mir.mli
+++ b/src/stan_math_backend/Transform_Mir.mli
@@ -5,5 +5,3 @@ the library implementation *)
 open Middle
 
 val trans_prog : Program.Typed.t -> Program.Typed.t
-val is_opencl_var : string -> bool
-val use_opencl : bool ref
diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml
index 951ec0566..1f11a8cb2 100644
--- a/src/stanc/stanc.ml
+++ b/src/stanc/stanc.ml
@@ -35,6 +35,7 @@ let dump_stan_math_distributions = ref false
 let opt_lvl = ref Optimize.O0
 let no_soa_opt = ref false
 let soa_opt = ref false
+let opencl_opt = ref false
 let output_file = ref ""
 let generate_data = ref false
 let generate_inits = ref false
@@ -190,6 +191,9 @@ let options =
     ; ( "-fsoa"
       , Arg.Unit (fun () -> soa_opt := true)
       , "\tTurn on the Struct of Arrays optimization" )
+    ; ( "--use-opencl"
+      , Arg.Unit (fun () -> opencl_opt := true)
+      , "\tTurn on OpenCL optimization" )
     ; ( "--o"
       , Arg.Set_string output_file
       , " Take the path to an output file for generated C++ code (default = \
@@ -207,9 +211,6 @@ let options =
             Preprocessor.include_paths := String.split_on_chars ~on:[','] str )
       , " Takes a comma-separated list of directories that may contain a file \
          in an #include directive (default = \"\")" )
-    ; ( "--use-opencl"
-      , Arg.Set Transform_Mir.use_opencl
-      , " If set, try to use matrix_cl signatures." )
     ; ( "--standalone-functions"
       , Arg.Set Lower_program.standalone_functions
       , " If set, the generated C++ will be the standalone functions C++ code."
@@ -359,7 +360,11 @@ let use_file filename =
         if !no_soa_opt then {base_optims with optimize_soa= false}
         else if !soa_opt then {base_optims with optimize_soa= true}
         else base_optims in
-      Optimize.optimization_suite ~settings:set_optims tx_mir in
+      let set_optims_opencl =
+        if !opencl_opt then
+          {set_optims with optimize_opencl= true; optimize_soa= false}
+        else set_optims in
+      Optimize.optimization_suite ~settings:set_optims_opencl tx_mir in
     if !dump_mem_pattern then
       Memory_patterns.pp_mem_patterns Format.std_formatter opt_mir ;
     if !dump_opt_mir then print_sexp [%sexp (opt_mir : Middle.Program.Typed.t)] ;
diff --git a/src/stancjs/stancjs.ml b/src/stancjs/stancjs.ml
index dff245a52..843327d81 100644
--- a/src/stancjs/stancjs.ml
+++ b/src/stancjs/stancjs.ml
@@ -19,7 +19,6 @@ let stan2cpp model_name model_string is_flag_set flag_val :
   Typechecker.model_name := model_name ;
   Typechecker.check_that_all_functions_have_definition :=
     not (is_flag_set "allow_undefined" || is_flag_set "allow-undefined") ;
-  Transform_Mir.use_opencl := is_flag_set "use-opencl" ;
   Lower_program.standalone_functions :=
     is_flag_set "standalone-functions" || is_flag_set "functions-only" ;
   With_return.with_return (fun r ->
@@ -126,9 +125,12 @@ let stan2cpp model_name model_string is_flag_set flag_val :
             else if is_flag_set "Oexperimental" || is_flag_set "O" then
               Optimize.Oexperimental
             else Optimize.O0 in
-          Optimize.optimization_suite
-            ~settings:(Optimize.level_optimizations opt_lvl)
-            tx_mir in
+          let opt_flags = Optimize.level_optimizations opt_lvl in
+          let opencl_optims =
+            if is_flag_set "use-opencl" then
+              {opt_flags with optimize_opencl= true; optimize_soa= false}
+            else opt_flags in
+          Optimize.optimization_suite ~settings:opencl_optims tx_mir in
         if is_flag_set "debug-optimized-mir" then
           r.return
             ( Result.Ok
diff --git a/test/integration/cli-args/canonicalize/canonicalize.t b/test/integration/cli-args/canonicalize/canonicalize.t
index adc76de77..1b8fc5970 100644
--- a/test/integration/cli-args/canonicalize/canonicalize.t
+++ b/test/integration/cli-args/canonicalize/canonicalize.t
@@ -34,11 +34,11 @@ Test that a nonsense argument is caught
     --O                             (Experimental) Same as --Oexperimental. Apply all compiler optimizations. Some of these are not thorougly tested and may not always improve a programs performance.
     -fno-soa                        Turn off the Struct of Arrays optimization
     -fsoa                           Turn on the Struct of Arrays optimization
+    --use-opencl                    Turn on OpenCL optimization
     --o                             Take the path to an output file for generated C++ code (default = "$name.hpp") or auto-formatting output (default: no file/print to stdout)
     --print-cpp                     If set, output the generated C++ Stan model class to stdout.
     --allow-undefined               Do not fail if a function is declared but not defined
     --include-paths                 Takes a comma-separated list of directories that may contain a file in an #include directive (default = "")
-    --use-opencl                    If set, try to use matrix_cl signatures.
     --standalone-functions          If set, the generated C++ will be the standalone functions C++ code.
     --filename-in-msg               Sets the filename used in compiler errors. Uses actual filename by default.
     --info                          If set, print information about the model.
@@ -81,11 +81,11 @@ Test capitalization - this should fail due to the lack of model_name, not the ca
     --O                             (Experimental) Same as --Oexperimental. Apply all compiler optimizations. Some of these are not thorougly tested and may not always improve a programs performance.
     -fno-soa                        Turn off the Struct of Arrays optimization
     -fsoa                           Turn on the Struct of Arrays optimization
+    --use-opencl                    Turn on OpenCL optimization
     --o                             Take the path to an output file for generated C++ code (default = "$name.hpp") or auto-formatting output (default: no file/print to stdout)
     --print-cpp                     If set, output the generated C++ Stan model class to stdout.
     --allow-undefined               Do not fail if a function is declared but not defined
     --include-paths                 Takes a comma-separated list of directories that may contain a file in an #include directive (default = "")
-    --use-opencl                    If set, try to use matrix_cl signatures.
     --standalone-functions          If set, the generated C++ will be the standalone functions C++ code.
     --filename-in-msg               Sets the filename used in compiler errors. Uses actual filename by default.
     --info                          If set, print information about the model.
diff --git a/test/integration/cli-args/stanc.t b/test/integration/cli-args/stanc.t
index 0cc3d1e1e..1ae0f2a8d 100644
--- a/test/integration/cli-args/stanc.t
+++ b/test/integration/cli-args/stanc.t
@@ -32,11 +32,11 @@ Show help
     --O                             (Experimental) Same as --Oexperimental. Apply all compiler optimizations. Some of these are not thorougly tested and may not always improve a programs performance.
     -fno-soa                        Turn off the Struct of Arrays optimization
     -fsoa                           Turn on the Struct of Arrays optimization
+    --use-opencl                    Turn on OpenCL optimization
     --o                             Take the path to an output file for generated C++ code (default = "$name.hpp") or auto-formatting output (default: no file/print to stdout)
     --print-cpp                     If set, output the generated C++ Stan model class to stdout.
     --allow-undefined               Do not fail if a function is declared but not defined
     --include-paths                 Takes a comma-separated list of directories that may contain a file in an #include directive (default = "")
-    --use-opencl                    If set, try to use matrix_cl signatures.
     --standalone-functions          If set, the generated C++ will be the standalone functions C++ code.
     --filename-in-msg               Sets the filename used in compiler errors. Uses actual filename by default.
     --info                          If set, print information about the model.
@@ -80,11 +80,11 @@ Error when no file passed
     --O                             (Experimental) Same as --Oexperimental. Apply all compiler optimizations. Some of these are not thorougly tested and may not always improve a programs performance.
     -fno-soa                        Turn off the Struct of Arrays optimization
     -fsoa                           Turn on the Struct of Arrays optimization
+    --use-opencl                    Turn on OpenCL optimization
     --o                             Take the path to an output file for generated C++ code (default = "$name.hpp") or auto-formatting output (default: no file/print to stdout)
     --print-cpp                     If set, output the generated C++ Stan model class to stdout.
     --allow-undefined               Do not fail if a function is declared but not defined
     --include-paths                 Takes a comma-separated list of directories that may contain a file in an #include directive (default = "")
-    --use-opencl                    If set, try to use matrix_cl signatures.
     --standalone-functions          If set, the generated C++ will be the standalone functions C++ code.
     --filename-in-msg               Sets the filename used in compiler errors. Uses actual filename by default.
     --info                          If set, print information about the model.
@@ -126,11 +126,11 @@ Error when multiple files passed
     --O                             (Experimental) Same as --Oexperimental. Apply all compiler optimizations. Some of these are not thorougly tested and may not always improve a programs performance.
     -fno-soa                        Turn off the Struct of Arrays optimization
     -fsoa                           Turn on the Struct of Arrays optimization
+    --use-opencl                    Turn on OpenCL optimization
     --o                             Take the path to an output file for generated C++ code (default = "$name.hpp") or auto-formatting output (default: no file/print to stdout)
     --print-cpp                     If set, output the generated C++ Stan model class to stdout.
     --allow-undefined               Do not fail if a function is declared but not defined
     --include-paths                 Takes a comma-separated list of directories that may contain a file in an #include directive (default = "")
-    --use-opencl                    If set, try to use matrix_cl signatures.
     --standalone-functions          If set, the generated C++ will be the standalone functions C++ code.
     --filename-in-msg               Sets the filename used in compiler errors. Uses actual filename by default.
     --info                          If set, print information about the model.
diff --git a/test/integration/good/code-gen/cl.expected b/test/integration/good/code-gen/cl.expected
index 6be762d8a..191a8e8b5 100644
--- a/test/integration/good/code-gen/cl.expected
+++ b/test/integration/good/code-gen/cl.expected
@@ -244,12 +244,22 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
   std::vector<int> y2_vi_d_td;
   int y_s_d_td;
   double y_r_d_td;
-  matrix_cl<double> X_d_opencl__;
-  matrix_cl<double> X_d_td_opencl__;
-  matrix_cl<double> y_v_d_opencl__;
-  matrix_cl<double> y_v_d_td_opencl__;
-  matrix_cl<int> y_vi_d_opencl__;
-  matrix_cl<double> y_vi_d_td_opencl__;
+  stan::math::matrix_cl<double> X_d_opencl__;
+  std::vector<Eigen::Matrix<stan::math::matrix_cl<double>,-1,-1>>
+    X_d_a_opencl__;
+  stan::math::matrix_cl<double> y_v_d_opencl__;
+  stan::math::matrix_cl<double> X_rv_d_opencl__;
+  stan::math::matrix_cl<int> y_vi_d_opencl__;
+  stan::math::matrix_cl<int> y2_vi_d_opencl__;
+  stan::math::matrix_cl<int> y_s_d_opencl__;
+  stan::math::matrix_cl<double> y_r_d_opencl__;
+  stan::math::matrix_cl<double> X_d_td_opencl__;
+  stan::math::matrix_cl<double> y_v_d_td_opencl__;
+  stan::math::matrix_cl<double> X_rv_d_td_opencl__;
+  stan::math::matrix_cl<int> y_vi_d_td_opencl__;
+  stan::math::matrix_cl<int> y2_vi_d_td_opencl__;
+  stan::math::matrix_cl<int> y_s_d_td_opencl__;
+  stan::math::matrix_cl<double> y_r_d_td_opencl__;
   Eigen::Map<Eigen::Matrix<double,-1,-1>> X_d{nullptr, 0, 0};
   Eigen::Map<Eigen::Matrix<double,-1,1>> y_v_d{nullptr, 0};
   Eigen::Map<Eigen::Matrix<double,1,-1>> X_rv_d{nullptr, 0};
@@ -473,12 +483,70 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
       stan::math::validate_non_negative_index("beta_m", "k", k);
       current_statement__ = 216;
       stan::math::validate_non_negative_index("X_rv_p", "n", n);
+      current_statement__ = 180;
       X_d_opencl__ = stan::math::to_matrix_cl(X_d);
-      X_d_td_opencl__ = stan::math::to_matrix_cl(X_d_td);
+      current_statement__ = 180;
+      X_d_opencl__ = stan::math::to_matrix_cl(X_d);
+      current_statement__ = 183;
+      X_d_a_opencl__ = std::vector<Eigen::Matrix<double,-1,-1>>(2,
+                         Eigen::Matrix<double,-1,-1>::Constant(n, k,
+                           std::numeric_limits<double>::quiet_NaN()));
+      current_statement__ = 183;
+      X_d_a_opencl__ = stan::math::to_matrix_cl(X_d_a);
+      current_statement__ = 185;
       y_v_d_opencl__ = stan::math::to_matrix_cl(y_v_d);
-      y_v_d_td_opencl__ = stan::math::to_matrix_cl(y_v_d_td);
+      current_statement__ = 185;
+      y_v_d_opencl__ = stan::math::to_matrix_cl(y_v_d);
+      current_statement__ = 187;
+      X_rv_d_opencl__ = stan::math::to_matrix_cl(X_rv_d);
+      current_statement__ = 187;
+      X_rv_d_opencl__ = stan::math::to_matrix_cl(X_rv_d);
+      current_statement__ = 189;
+      y_vi_d_opencl__ = std::vector<int>(n, std::numeric_limits<int>::min());
+      current_statement__ = 189;
       y_vi_d_opencl__ = stan::math::to_matrix_cl(y_vi_d);
+      current_statement__ = 191;
+      y2_vi_d_opencl__ = std::vector<int>(n, std::numeric_limits<int>::min());
+      current_statement__ = 191;
+      y2_vi_d_opencl__ = stan::math::to_matrix_cl(y2_vi_d);
+      current_statement__ = 192;
+      y_s_d_opencl__ = std::numeric_limits<int>::min();
+      current_statement__ = 192;
+      y_s_d_opencl__ = stan::math::to_matrix_cl(y_s_d);
+      current_statement__ = 193;
+      y_r_d_opencl__ = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 193;
+      y_r_d_opencl__ = stan::math::to_matrix_cl(y_r_d);
+      current_statement__ = 198;
+      X_d_td_opencl__ = stan::math::to_matrix_cl(X_d_td);
+      current_statement__ = 198;
+      X_d_td_opencl__ = stan::math::to_matrix_cl(X_d_td);
+      current_statement__ = 200;
+      y_v_d_td_opencl__ = stan::math::to_matrix_cl(y_v_d_td);
+      current_statement__ = 200;
+      y_v_d_td_opencl__ = stan::math::to_matrix_cl(y_v_d_td);
+      current_statement__ = 202;
+      X_rv_d_td_opencl__ = stan::math::to_matrix_cl(X_rv_d_td);
+      current_statement__ = 202;
+      X_rv_d_td_opencl__ = stan::math::to_matrix_cl(X_rv_d_td);
+      current_statement__ = 204;
+      y_vi_d_td_opencl__ = std::vector<int>(n,
+                             std::numeric_limits<int>::min());
+      current_statement__ = 204;
       y_vi_d_td_opencl__ = stan::math::to_matrix_cl(y_vi_d_td);
+      current_statement__ = 206;
+      y2_vi_d_td_opencl__ = std::vector<int>(n,
+                              std::numeric_limits<int>::min());
+      current_statement__ = 206;
+      y2_vi_d_td_opencl__ = stan::math::to_matrix_cl(y2_vi_d_td);
+      current_statement__ = 207;
+      y_s_d_td_opencl__ = std::numeric_limits<int>::min();
+      current_statement__ = 207;
+      y_s_d_td_opencl__ = stan::math::to_matrix_cl(y_s_d_td);
+      current_statement__ = 208;
+      y_r_d_td_opencl__ = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 208;
+      y_r_d_td_opencl__ = stan::math::to_matrix_cl(y_r_d_td);
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
     }
@@ -550,39 +618,29 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
       X_rv_p = in__.template read<Eigen::Matrix<local_scalar_t__,1,-1>>(n);
       {
         current_statement__ = 10;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d_opencl__,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta),
-                         sigma));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d, X_d,
+                         alpha, beta, sigma));
         current_statement__ = 11;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
-                         y_v_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), sigma));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_v_d, X_d,
+                         alpha, beta, sigma));
         current_statement__ = 12;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d_opencl__,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta), sigma));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d, X_p,
+                         alpha, beta, sigma));
         current_statement__ = 13;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
-                         y_v_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), sigma));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_v_d, X_p,
+                         alpha, beta, sigma));
         current_statement__ = 14;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_r_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_r_d, X_d,
+                         alpha, beta, beta));
         current_statement__ = 15;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_r_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_r_d, X_d,
+                         alpha, beta, beta));
         current_statement__ = 16;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_r_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_r_d, X_p,
+                         alpha, beta, beta));
         current_statement__ = 17;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_r_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_r_d, X_p,
+                         alpha, beta, beta));
         current_statement__ = 18;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d, X_rv_d,
                          alpha, beta, beta));
@@ -596,41 +654,29 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
         lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_v_d,
                          X_rv_p, alpha, beta, beta));
         current_statement__ = 22;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(
-                         y_v_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), sigma));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d_td,
+                         X_d_td, alpha, beta, sigma));
         current_statement__ = 23;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
-                         y_v_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), sigma));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_v_d_td,
+                         X_d_td, alpha, beta, sigma));
         current_statement__ = 24;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(
-                         y_v_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), sigma));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d_td, X_p,
+                         alpha, beta, sigma));
         current_statement__ = 25;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
-                         y_v_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), sigma));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_v_d_td,
+                         X_p, alpha, beta, sigma));
         current_statement__ = 26;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_r_d_td,
-                         X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+                         X_d_td, alpha, beta, beta));
         current_statement__ = 27;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_r_d_td,
-                         X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+                         X_d_td, alpha, beta, beta));
         current_statement__ = 28;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_r_d_td,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_r_d_td, X_p,
+                         alpha, beta, beta));
         current_statement__ = 29;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_r_d_td,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+                         X_p, alpha, beta, beta));
         current_statement__ = 30;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d_td,
                          X_rv_d_td, alpha, beta, beta));
@@ -644,21 +690,17 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
         lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_v_d_td,
                          X_rv_p, alpha, beta, beta));
         current_statement__ = 34;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
-                         y_vi_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_vi_d,
+                         X_d, alpha, beta));
         current_statement__ = 35;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(y_vi_d,
+                         X_d, alpha, beta));
         current_statement__ = 36;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_vi_d,
+                         X_p, alpha, beta));
         current_statement__ = 37;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(y_vi_d,
+                         X_p, alpha, beta));
         current_statement__ = 38;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_vi_d,
                          X_rv_d, alpha, beta));
@@ -673,34 +715,28 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
                          X_rv_p, alpha, beta));
         current_statement__ = 42;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_s_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta)));
+                         X_d, alpha, beta));
         current_statement__ = 43;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(y_s_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta)));
+                         X_d, alpha, beta));
         current_statement__ = 44;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_s_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         X_p, alpha, beta));
         current_statement__ = 45;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(y_s_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         X_p, alpha, beta));
         current_statement__ = 46;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_vi_d_td,
+                         X_d_td, alpha, beta));
         current_statement__ = 47;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         y_vi_d_td, X_d_td, alpha, beta));
         current_statement__ = 48;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_vi_d_td,
+                         X_p, alpha, beta));
         current_statement__ = 49;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+                         y_vi_d_td, X_p, alpha, beta));
         current_statement__ = 50;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_vi_d_td,
                          X_rv_d_td, alpha, beta));
@@ -715,50 +751,40 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
                          y_vi_d_td, X_rv_p, alpha, beta));
         current_statement__ = 54;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_s_d_td,
-                         X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         X_d_td, alpha, beta));
         current_statement__ = 55;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_s_d_td, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         y_s_d_td, X_d_td, alpha, beta));
         current_statement__ = 56;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_s_d_td,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         X_p, alpha, beta));
         current_statement__ = 57;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         y_s_d_td, X_p, alpha, beta));
         current_statement__ = 58;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
-                         y_vi_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_vi_d, X_d,
+                         alpha, beta));
         current_statement__ = 59;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_vi_d,
+                         X_d, alpha, beta));
         current_statement__ = 60;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_vi_d, X_p,
+                         alpha, beta));
         current_statement__ = 61;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_vi_d,
+                         X_p, alpha, beta));
         current_statement__ = 62;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_s_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_s_d, X_d,
+                         alpha, beta));
         current_statement__ = 63;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_s_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_s_d, X_d,
+                         alpha, beta));
         current_statement__ = 64;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_s_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_s_d, X_p,
+                         alpha, beta));
         current_statement__ = 65;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_s_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_s_d, X_p,
+                         alpha, beta));
         current_statement__ = 66;
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_vi_d,
                          X_rv_d, alpha, beta));
@@ -772,37 +798,29 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_vi_d,
                          X_rv_p, alpha, beta));
         current_statement__ = 70;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_vi_d_td,
+                         X_d_td, alpha, beta));
         current_statement__ = 71;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_vi_d_td,
+                         X_d_td, alpha, beta));
         current_statement__ = 72;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_vi_d_td,
+                         X_p, alpha, beta));
         current_statement__ = 73;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_vi_d_td,
+                         X_p, alpha, beta));
         current_statement__ = 74;
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_s_d_td,
-                         X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         X_d_td, alpha, beta));
         current_statement__ = 75;
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_s_d_td,
-                         X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         X_d_td, alpha, beta));
         current_statement__ = 76;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_s_d_td,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_s_d_td, X_p,
+                         alpha, beta));
         current_statement__ = 77;
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_s_d_td,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         X_p, alpha, beta));
         current_statement__ = 78;
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_vi_d_td,
                          X_rv_d_td, alpha, beta));
@@ -816,37 +834,29 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_vi_d_td,
                          X_rv_p, alpha, beta));
         current_statement__ = 82;
-        lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_vi_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+        lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(y_vi_d,
+                         X_d, alpha, beta, phi));
         current_statement__ = 83;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d, X_d, alpha, beta, phi));
         current_statement__ = 84;
-        lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), phi));
+        lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(y_vi_d,
+                         X_p, alpha, beta, phi));
         current_statement__ = 85;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d, X_p, alpha, beta, phi));
         current_statement__ = 86;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(y_s_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta),
-                         phi));
+                         X_d, alpha, beta, phi));
         current_statement__ = 87;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_s_d, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_s_d, X_d, alpha, beta, phi));
         current_statement__ = 88;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(y_s_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         X_p, alpha, beta, phi));
         current_statement__ = 89;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_s_d, stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_s_d, X_p, alpha, beta, phi));
         current_statement__ = 90;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(y_vi_d,
                          X_rv_d, alpha, beta, phi));
@@ -861,36 +871,28 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
                          y_vi_d, X_rv_p, alpha, beta, phi));
         current_statement__ = 94;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d_td, X_d_td, alpha, beta, phi));
         current_statement__ = 95;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d_td, X_d_td, alpha, beta, phi));
         current_statement__ = 96;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d_td, X_p, alpha, beta, phi));
         current_statement__ = 97;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d_td, X_p, alpha, beta, phi));
         current_statement__ = 98;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_s_d_td, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_s_d_td, X_d_td, alpha, beta, phi));
         current_statement__ = 99;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_s_d_td, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_s_d_td, X_d_td, alpha, beta, phi));
         current_statement__ = 100;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_s_d_td, X_p, alpha, beta, phi));
         current_statement__ = 101;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_s_d_td, X_p, alpha, beta, phi));
         current_statement__ = 102;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
                          y_vi_d_td, X_rv_d_td, alpha, beta, phi));
@@ -905,78 +907,52 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
                          y_vi_d_td, X_rv_p, alpha, beta, phi));
         current_statement__ = 106;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d,
-                         X_d_opencl__, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         X_d, beta, cuts));
         current_statement__ = 107;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(y_s_d,
-                         X_d_opencl__, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         X_d, beta, cuts));
         current_statement__ = 108;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         X_p, beta, cuts));
         current_statement__ = 109;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(y_s_d,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         X_p, beta, cuts));
         current_statement__ = 110;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d_td,
-                         X_d_td_opencl__, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         X_d_td, beta, cuts));
         current_statement__ = 111;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_s_d_td, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_s_d_td, X_d_td, beta, cuts));
         current_statement__ = 112;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d_td,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         X_p, beta, cuts));
         current_statement__ = 113;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_s_d_td, X_p, beta, cuts));
         current_statement__ = 114;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d,
-                         X_d_opencl__, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         X_d, beta, cuts));
         current_statement__ = 115;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(y_s_d,
-                         X_d_opencl__, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         X_d, beta, cuts));
         current_statement__ = 116;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         X_p, beta, cuts));
         current_statement__ = 117;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(y_s_d,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         X_p, beta, cuts));
         current_statement__ = 118;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d_td,
-                         X_d_td_opencl__, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         X_d_td, beta, cuts));
         current_statement__ = 119;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_s_d_td, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_s_d_td, X_d_td, beta, cuts));
         current_statement__ = 120;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d_td,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         X_p, beta, cuts));
         current_statement__ = 121;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_s_d_td, X_p, beta, cuts));
         current_statement__ = 122;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d,
                          X_rv_d, beta, cuts));
@@ -990,45 +966,29 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(y_s_d,
                          X_rv_p, beta, cuts));
         current_statement__ = 126;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
-                         y_vi_d_opencl__, X_d_opencl__,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_vi_d,
+                         X_d, beta, cuts));
         current_statement__ = 127;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, X_d_opencl__,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d, X_d, beta, cuts));
         current_statement__ = 128;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_vi_d,
+                         X_p, beta, cuts));
         current_statement__ = 129;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d, X_p, beta, cuts));
         current_statement__ = 130;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d_td, X_d_td, beta, cuts));
         current_statement__ = 131;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d_td, X_d_td, beta, cuts));
         current_statement__ = 132;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d_td, X_p, beta, cuts));
         current_statement__ = 133;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d_td, X_p, beta, cuts));
         current_statement__ = 134;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_vi_d,
                          X_rv_d, beta, cuts));
@@ -1043,43 +1003,28 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
                          y_vi_d, X_rv_p, beta, cuts));
         current_statement__ = 138;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(y_s_d,
-                         X_d_opencl__, stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         X_d, alpha_v, beta_m));
         current_statement__ = 139;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_s_d, X_d_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_s_d, X_d, alpha_v, beta_m));
         current_statement__ = 140;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(y_s_d,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         X_p, alpha_v, beta_m));
         current_statement__ = 141;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_s_d, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_s_d, X_p, alpha_v, beta_m));
         current_statement__ = 142;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_s_d_td, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_s_d_td, X_d_td, alpha_v, beta_m));
         current_statement__ = 143;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_s_d_td, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_s_d_td, X_d_td, alpha_v, beta_m));
         current_statement__ = 144;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_s_d_td, X_p, alpha_v, beta_m));
         current_statement__ = 145;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_s_d_td, X_p, alpha_v, beta_m));
         current_statement__ = 146;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(y_s_d,
                          X_rv_d, alpha_v, beta_m));
@@ -1105,45 +1050,29 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
                          y_s_d_td, X_rv_p, alpha_v, beta_m));
         current_statement__ = 154;
-        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_vi_d_opencl__, X_d_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(y_vi_d,
+                         X_d, alpha_v, beta_m));
         current_statement__ = 155;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, X_d_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d, X_d, alpha_v, beta_m));
         current_statement__ = 156;
-        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(y_vi_d,
+                         X_p, alpha_v, beta_m));
         current_statement__ = 157;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d, X_p, alpha_v, beta_m));
         current_statement__ = 158;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d_td, X_d_td, alpha_v, beta_m));
         current_statement__ = 159;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d_td, X_d_td, alpha_v, beta_m));
         current_statement__ = 160;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d_td, X_p, alpha_v, beta_m));
         current_statement__ = 161;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d_td, X_p, alpha_v, beta_m));
         current_statement__ = 162;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(y_vi_d,
                          X_rv_d, alpha_v, beta_m));
@@ -1181,25 +1110,14 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
                          y2_vi_d_td, X_rv_p, alpha_v, beta_m));
         current_statement__ = 174;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d_opencl__,
-                         stan::math::to_matrix_cl(
-                           stan::model::rvalue(X_d_a, "X_d_a",
-                             stan::model::index_uni(1))), alpha,
-                         stan::math::to_matrix_cl(beta), sigma));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d,
+                         stan::model::rvalue(X_d_a, "X_d_a",
+                           stan::model::index_uni(1)), alpha, beta, sigma));
         current_statement__ = 175;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
-                         y_v_d_opencl__,
-                         stan::math::to_matrix_cl(
-                           stan::model::rvalue(X_d_a, "X_d_a",
-                             stan::model::index_uni(1))), alpha,
-                         stan::math::to_matrix_cl(beta), sigma));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_v_d,
+                         stan::model::rvalue(X_d_a, "X_d_a",
+                           stan::model::index_uni(1)), alpha, beta, sigma));
       }
-      X_d_opencl__.wait_for_read_write_events();
-      X_d_td_opencl__.wait_for_read_write_events();
-      y_v_d_opencl__.wait_for_read_write_events();
-      y_v_d_td_opencl__.wait_for_read_write_events();
-      y_vi_d_opencl__.wait_for_read_write_events();
-      y_vi_d_td_opencl__.wait_for_read_write_events();
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
     }
@@ -1228,693 +1146,579 @@ class optimize_glm_model final : public model_base_crtp<optimize_glm_model> {
     // suppress unused var warning
     (void) function__;
     try {
-      Eigen::Matrix<local_scalar_t__,-1,1> alpha_v =
-        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(k, DUMMY_VAR__);
+      stan::math::var_value<stan::math::matrix_cl<double>> alpha_v =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,1>::Constant(k,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
       current_statement__ = 1;
-      alpha_v = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(k);
-      Eigen::Matrix<local_scalar_t__,-1,1> beta =
-        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(k, DUMMY_VAR__);
+      alpha_v = in__.template read<
+                  stan::math::var_value<stan::math::matrix_cl<double>>>(k);
+      stan::math::var_value<stan::math::matrix_cl<double>> beta =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,1>::Constant(k,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
       current_statement__ = 2;
-      beta = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(k);
-      Eigen::Matrix<local_scalar_t__,-1,1> cuts =
-        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(k, DUMMY_VAR__);
+      beta = in__.template read<
+               stan::math::var_value<stan::math::matrix_cl<double>>>(k);
+      stan::math::var_value<stan::math::matrix_cl<double>> cuts =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,1>::Constant(k,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
       current_statement__ = 3;
-      cuts = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(k);
-      local_scalar_t__ sigma = DUMMY_VAR__;
+      cuts = in__.template read<
+               stan::math::var_value<stan::math::matrix_cl<double>>>(k);
+      stan::math::matrix_cl<local_scalar_t__> sigma = DUMMY_VAR__;
       current_statement__ = 4;
-      sigma = in__.template read_constrain_lb<local_scalar_t__,
-                jacobian__>(0, lp__);
-      local_scalar_t__ alpha = DUMMY_VAR__;
+      sigma = in__.template read_constrain_lb<
+                stan::math::matrix_cl<local_scalar_t__>, jacobian__>(0, lp__);
+      stan::math::matrix_cl<local_scalar_t__> alpha = DUMMY_VAR__;
       current_statement__ = 5;
-      alpha = in__.template read<local_scalar_t__>();
-      local_scalar_t__ phi = DUMMY_VAR__;
+      alpha = in__.template read<stan::math::matrix_cl<local_scalar_t__>>();
+      stan::math::matrix_cl<local_scalar_t__> phi = DUMMY_VAR__;
       current_statement__ = 6;
-      phi = in__.template read<local_scalar_t__>();
-      Eigen::Matrix<local_scalar_t__,-1,-1> X_p =
-        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(n, k, DUMMY_VAR__);
+      phi = in__.template read<stan::math::matrix_cl<local_scalar_t__>>();
+      stan::math::var_value<stan::math::matrix_cl<double>> X_p =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,-1>::Constant(n,
+                                                               k,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
       current_statement__ = 7;
-      X_p = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(n, k);
-      Eigen::Matrix<local_scalar_t__,-1,-1> beta_m =
-        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(n, k, DUMMY_VAR__);
+      X_p = in__.template read<
+              stan::math::var_value<stan::math::matrix_cl<double>>>(n, k);
+      stan::math::var_value<stan::math::matrix_cl<double>> beta_m =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,-1>::Constant(n,
+                                                               k,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
       current_statement__ = 8;
-      beta_m = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(n,
-                 k);
-      Eigen::Matrix<local_scalar_t__,1,-1> X_rv_p =
-        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(n, DUMMY_VAR__);
+      beta_m = in__.template read<
+                 stan::math::var_value<stan::math::matrix_cl<double>>>(n, k);
+      stan::math::var_value<stan::math::matrix_cl<double>> X_rv_p =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,1,-1>::Constant(n,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
       current_statement__ = 9;
-      X_rv_p = in__.template read<Eigen::Matrix<local_scalar_t__,1,-1>>(n);
+      X_rv_p = in__.template read<
+                 stan::math::var_value<stan::math::matrix_cl<double>>>(n);
       {
         current_statement__ = 10;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d_opencl__,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta),
-                         sigma));
+                         X_d_opencl__, alpha, beta, sigma));
         current_statement__ = 11;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
-                         y_v_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), sigma));
+                         y_v_d_opencl__, X_d_opencl__, alpha, beta, sigma));
         current_statement__ = 12;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d_opencl__,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta), sigma));
+                         X_p, alpha, beta, sigma));
         current_statement__ = 13;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
-                         y_v_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), sigma));
+                         y_v_d_opencl__, X_p, alpha, beta, sigma));
         current_statement__ = 14;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_r_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_r_d_opencl__,
+                         X_d_opencl__, alpha, beta, beta));
         current_statement__ = 15;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_r_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
+                         y_r_d_opencl__, X_d_opencl__, alpha, beta, beta));
         current_statement__ = 16;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_r_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_r_d_opencl__,
+                         X_p, alpha, beta, beta));
         current_statement__ = 17;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_r_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
+                         y_r_d_opencl__, X_p, alpha, beta, beta));
         current_statement__ = 18;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d, X_rv_d,
-                         alpha, beta, beta));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d_opencl__,
+                         X_rv_d_opencl__, alpha, beta, beta));
         current_statement__ = 19;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_v_d,
-                         X_rv_d, alpha, beta, beta));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
+                         y_v_d_opencl__, X_rv_d_opencl__, alpha, beta, beta));
         current_statement__ = 20;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d, X_rv_p,
-                         alpha, beta, beta));
-        current_statement__ = 21;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_v_d,
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d_opencl__,
                          X_rv_p, alpha, beta, beta));
+        current_statement__ = 21;
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
+                         y_v_d_opencl__, X_rv_p, alpha, beta, beta));
         current_statement__ = 22;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(
-                         y_v_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), sigma));
+                         y_v_d_td_opencl__, X_d_td_opencl__, alpha, beta,
+                         sigma));
         current_statement__ = 23;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
-                         y_v_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), sigma));
+                         y_v_d_td_opencl__, X_d_td_opencl__, alpha, beta,
+                         sigma));
         current_statement__ = 24;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(
-                         y_v_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), sigma));
+                         y_v_d_td_opencl__, X_p, alpha, beta, sigma));
         current_statement__ = 25;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
-                         y_v_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), sigma));
+                         y_v_d_td_opencl__, X_p, alpha, beta, sigma));
         current_statement__ = 26;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_r_d_td,
-                         X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(
+                         y_r_d_td_opencl__, X_d_td_opencl__, alpha, beta,
+                         beta));
         current_statement__ = 27;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_r_d_td,
-                         X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
+                         y_r_d_td_opencl__, X_d_td_opencl__, alpha, beta,
+                         beta));
         current_statement__ = 28;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_r_d_td,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(
+                         y_r_d_td_opencl__, X_p, alpha, beta, beta));
         current_statement__ = 29;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_r_d_td,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
+                         y_r_d_td_opencl__, X_p, alpha, beta, beta));
         current_statement__ = 30;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d_td,
-                         X_rv_d_td, alpha, beta, beta));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(
+                         y_v_d_td_opencl__, X_rv_d_td_opencl__, alpha, beta,
+                         beta));
         current_statement__ = 31;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_v_d_td,
-                         X_rv_d_td, alpha, beta, beta));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
+                         y_v_d_td_opencl__, X_rv_d_td_opencl__, alpha, beta,
+                         beta));
         current_statement__ = 32;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d_td,
-                         X_rv_p, alpha, beta, beta));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(
+                         y_v_d_td_opencl__, X_rv_p, alpha, beta, beta));
         current_statement__ = 33;
-        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(y_v_d_td,
-                         X_rv_p, alpha, beta, beta));
+        lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
+                         y_v_d_td_opencl__, X_rv_p, alpha, beta, beta));
         current_statement__ = 34;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
-                         y_vi_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         y_vi_d_opencl__, X_d_opencl__, alpha, beta));
         current_statement__ = 35;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         y_vi_d_opencl__, X_d_opencl__, alpha, beta));
         current_statement__ = 36;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+                         y_vi_d_opencl__, X_p, alpha, beta));
         current_statement__ = 37;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+                         y_vi_d_opencl__, X_p, alpha, beta));
         current_statement__ = 38;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_vi_d,
-                         X_rv_d, alpha, beta));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
+                         y_vi_d_opencl__, X_rv_d_opencl__, alpha, beta));
         current_statement__ = 39;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(y_vi_d,
-                         X_rv_d, alpha, beta));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
+                         y_vi_d_opencl__, X_rv_d_opencl__, alpha, beta));
         current_statement__ = 40;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_vi_d,
-                         X_rv_p, alpha, beta));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
+                         y_vi_d_opencl__, X_rv_p, alpha, beta));
         current_statement__ = 41;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(y_vi_d,
-                         X_rv_p, alpha, beta));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
+                         y_vi_d_opencl__, X_rv_p, alpha, beta));
         current_statement__ = 42;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_s_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
+                         y_s_d_opencl__, X_d_opencl__, alpha, beta));
         current_statement__ = 43;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(y_s_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
+                         y_s_d_opencl__, X_d_opencl__, alpha, beta));
         current_statement__ = 44;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_s_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
+                         y_s_d_opencl__, X_p, alpha, beta));
         current_statement__ = 45;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(y_s_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
+                         y_s_d_opencl__, X_p, alpha, beta));
         current_statement__ = 46;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha, beta));
         current_statement__ = 47;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha, beta));
         current_statement__ = 48;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+                         y_vi_d_td_opencl__, X_p, alpha, beta));
         current_statement__ = 49;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+                         y_vi_d_td_opencl__, X_p, alpha, beta));
         current_statement__ = 50;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_vi_d_td,
-                         X_rv_d_td, alpha, beta));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
+                         y_vi_d_td_opencl__, X_rv_d_td_opencl__, alpha, beta));
         current_statement__ = 51;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_vi_d_td, X_rv_d_td, alpha, beta));
+                         y_vi_d_td_opencl__, X_rv_d_td_opencl__, alpha, beta));
         current_statement__ = 52;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_vi_d_td,
-                         X_rv_p, alpha, beta));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
+                         y_vi_d_td_opencl__, X_rv_p, alpha, beta));
         current_statement__ = 53;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_vi_d_td, X_rv_p, alpha, beta));
+                         y_vi_d_td_opencl__, X_rv_p, alpha, beta));
         current_statement__ = 54;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_s_d_td,
-                         X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
+                         y_s_d_td_opencl__, X_d_td_opencl__, alpha, beta));
         current_statement__ = 55;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_s_d_td, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         y_s_d_td_opencl__, X_d_td_opencl__, alpha, beta));
         current_statement__ = 56;
-        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(y_s_d_td,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<false>(
+                         y_s_d_td_opencl__, X_p, alpha, beta));
         current_statement__ = 57;
         lp_accum__.add(stan::math::bernoulli_logit_glm_lpmf<propto__>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         y_s_d_td_opencl__, X_p, alpha, beta));
         current_statement__ = 58;
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
-                         y_vi_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         y_vi_d_opencl__, X_d_opencl__, alpha, beta));
         current_statement__ = 59;
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         y_vi_d_opencl__, X_d_opencl__, alpha, beta));
         current_statement__ = 60;
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+                         y_vi_d_opencl__, X_p, alpha, beta));
         current_statement__ = 61;
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+                         y_vi_d_opencl__, X_p, alpha, beta));
         current_statement__ = 62;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_s_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
+                         y_s_d_opencl__, X_d_opencl__, alpha, beta));
         current_statement__ = 63;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_s_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
+                         y_s_d_opencl__, X_d_opencl__, alpha, beta));
         current_statement__ = 64;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_s_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
+                         y_s_d_opencl__, X_p, alpha, beta));
         current_statement__ = 65;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_s_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
+                         y_s_d_opencl__, X_p, alpha, beta));
         current_statement__ = 66;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_vi_d,
-                         X_rv_d, alpha, beta));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
+                         y_vi_d_opencl__, X_rv_d_opencl__, alpha, beta));
         current_statement__ = 67;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_vi_d,
-                         X_rv_d, alpha, beta));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
+                         y_vi_d_opencl__, X_rv_d_opencl__, alpha, beta));
         current_statement__ = 68;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_vi_d,
-                         X_rv_p, alpha, beta));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
+                         y_vi_d_opencl__, X_rv_p, alpha, beta));
         current_statement__ = 69;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_vi_d,
-                         X_rv_p, alpha, beta));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
+                         y_vi_d_opencl__, X_rv_p, alpha, beta));
         current_statement__ = 70;
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha, beta));
         current_statement__ = 71;
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha, beta));
         current_statement__ = 72;
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+                         y_vi_d_td_opencl__, X_p, alpha, beta));
         current_statement__ = 73;
         lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta)));
+                         y_vi_d_td_opencl__, X_p, alpha, beta));
         current_statement__ = 74;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_s_d_td,
-                         X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
+                         y_s_d_td_opencl__, X_d_td_opencl__, alpha, beta));
         current_statement__ = 75;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_s_d_td,
-                         X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
+                         y_s_d_td_opencl__, X_d_td_opencl__, alpha, beta));
         current_statement__ = 76;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_s_d_td,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
+                         y_s_d_td_opencl__, X_p, alpha, beta));
         current_statement__ = 77;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_s_d_td,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta)));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
+                         y_s_d_td_opencl__, X_p, alpha, beta));
         current_statement__ = 78;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_vi_d_td,
-                         X_rv_d_td, alpha, beta));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
+                         y_vi_d_td_opencl__, X_rv_d_td_opencl__, alpha, beta));
         current_statement__ = 79;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_vi_d_td,
-                         X_rv_d_td, alpha, beta));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
+                         y_vi_d_td_opencl__, X_rv_d_td_opencl__, alpha, beta));
         current_statement__ = 80;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(y_vi_d_td,
-                         X_rv_p, alpha, beta));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<false>(
+                         y_vi_d_td_opencl__, X_rv_p, alpha, beta));
         current_statement__ = 81;
-        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(y_vi_d_td,
-                         X_rv_p, alpha, beta));
+        lp_accum__.add(stan::math::poisson_log_glm_lpmf<propto__>(
+                         y_vi_d_td_opencl__, X_rv_p, alpha, beta));
         current_statement__ = 82;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_vi_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d_opencl__, X_d_opencl__, alpha, beta, phi));
         current_statement__ = 83;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d_opencl__, X_d_opencl__, alpha, beta, phi));
         current_statement__ = 84;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d_opencl__, X_p, alpha, beta, phi));
         current_statement__ = 85;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d_opencl__, X_p, alpha, beta, phi));
         current_statement__ = 86;
-        lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(y_s_d,
-                         X_d_opencl__, alpha, stan::math::to_matrix_cl(beta),
-                         phi));
+        lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
+                         y_s_d_opencl__, X_d_opencl__, alpha, beta, phi));
         current_statement__ = 87;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_s_d, X_d_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_s_d_opencl__, X_d_opencl__, alpha, beta, phi));
         current_statement__ = 88;
-        lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(y_s_d,
-                         stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+        lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
+                         y_s_d_opencl__, X_p, alpha, beta, phi));
         current_statement__ = 89;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_s_d, stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_s_d_opencl__, X_p, alpha, beta, phi));
         current_statement__ = 90;
-        lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(y_vi_d,
-                         X_rv_d, alpha, beta, phi));
+        lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
+                         y_vi_d_opencl__, X_rv_d_opencl__, alpha, beta, phi));
         current_statement__ = 91;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_vi_d, X_rv_d, alpha, beta, phi));
+                         y_vi_d_opencl__, X_rv_d_opencl__, alpha, beta, phi));
         current_statement__ = 92;
-        lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(y_vi_d,
-                         X_rv_p, alpha, beta, phi));
+        lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
+                         y_vi_d_opencl__, X_rv_p, alpha, beta, phi));
         current_statement__ = 93;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_vi_d, X_rv_p, alpha, beta, phi));
+                         y_vi_d_opencl__, X_rv_p, alpha, beta, phi));
         current_statement__ = 94;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha, beta,
+                         phi));
         current_statement__ = 95;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha, beta,
+                         phi));
         current_statement__ = 96;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d_td_opencl__, X_p, alpha, beta, phi));
         current_statement__ = 97;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         alpha, stan::math::to_matrix_cl(beta), phi));
+                         y_vi_d_td_opencl__, X_p, alpha, beta, phi));
         current_statement__ = 98;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_s_d_td, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_s_d_td_opencl__, X_d_td_opencl__, alpha, beta, phi));
         current_statement__ = 99;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_s_d_td, X_d_td_opencl__, alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_s_d_td_opencl__, X_d_td_opencl__, alpha, beta, phi));
         current_statement__ = 100;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_s_d_td_opencl__, X_p, alpha, beta, phi));
         current_statement__ = 101;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p), alpha,
-                         stan::math::to_matrix_cl(beta), phi));
+                         y_s_d_td_opencl__, X_p, alpha, beta, phi));
         current_statement__ = 102;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_vi_d_td, X_rv_d_td, alpha, beta, phi));
+                         y_vi_d_td_opencl__, X_rv_d_td_opencl__, alpha, beta,
+                         phi));
         current_statement__ = 103;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_vi_d_td, X_rv_d_td, alpha, beta, phi));
+                         y_vi_d_td_opencl__, X_rv_d_td_opencl__, alpha, beta,
+                         phi));
         current_statement__ = 104;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<false>(
-                         y_vi_d_td, X_rv_p, alpha, beta, phi));
+                         y_vi_d_td_opencl__, X_rv_p, alpha, beta, phi));
         current_statement__ = 105;
         lp_accum__.add(stan::math::neg_binomial_2_log_glm_lpmf<propto__>(
-                         y_vi_d_td, X_rv_p, alpha, beta, phi));
+                         y_vi_d_td_opencl__, X_rv_p, alpha, beta, phi));
         current_statement__ = 106;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d,
-                         X_d_opencl__, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
+                         y_s_d_opencl__, X_d_opencl__, beta, cuts));
         current_statement__ = 107;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(y_s_d,
-                         X_d_opencl__, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
+                         y_s_d_opencl__, X_d_opencl__, beta, cuts));
         current_statement__ = 108;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
+                         y_s_d_opencl__, X_p, beta, cuts));
         current_statement__ = 109;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(y_s_d,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
+                         y_s_d_opencl__, X_p, beta, cuts));
         current_statement__ = 110;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d_td,
-                         X_d_td_opencl__, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
+                         y_s_d_td_opencl__, X_d_td_opencl__, beta, cuts));
         current_statement__ = 111;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_s_d_td, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_s_d_td_opencl__, X_d_td_opencl__, beta, cuts));
         current_statement__ = 112;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d_td,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
+                         y_s_d_td_opencl__, X_p, beta, cuts));
         current_statement__ = 113;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_s_d_td_opencl__, X_p, beta, cuts));
         current_statement__ = 114;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d,
-                         X_d_opencl__, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
+                         y_s_d_opencl__, X_d_opencl__, beta, cuts));
         current_statement__ = 115;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(y_s_d,
-                         X_d_opencl__, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
+                         y_s_d_opencl__, X_d_opencl__, beta, cuts));
         current_statement__ = 116;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
+                         y_s_d_opencl__, X_p, beta, cuts));
         current_statement__ = 117;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(y_s_d,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
+                         y_s_d_opencl__, X_p, beta, cuts));
         current_statement__ = 118;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d_td,
-                         X_d_td_opencl__, stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
+                         y_s_d_td_opencl__, X_d_td_opencl__, beta, cuts));
         current_statement__ = 119;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_s_d_td, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_s_d_td_opencl__, X_d_td_opencl__, beta, cuts));
         current_statement__ = 120;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d_td,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
+                         y_s_d_td_opencl__, X_p, beta, cuts));
         current_statement__ = 121;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_s_d_td_opencl__, X_p, beta, cuts));
         current_statement__ = 122;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d,
-                         X_rv_d, beta, cuts));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
+                         y_s_d_opencl__, X_rv_d_opencl__, beta, cuts));
         current_statement__ = 123;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(y_s_d,
-                         X_rv_d, beta, cuts));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
+                         y_s_d_opencl__, X_rv_d_opencl__, beta, cuts));
         current_statement__ = 124;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_s_d,
-                         X_rv_p, beta, cuts));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
+                         y_s_d_opencl__, X_rv_p, beta, cuts));
         current_statement__ = 125;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(y_s_d,
-                         X_rv_p, beta, cuts));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
+                         y_s_d_opencl__, X_rv_p, beta, cuts));
         current_statement__ = 126;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
-                         y_vi_d_opencl__, X_d_opencl__,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d_opencl__, X_d_opencl__, beta, cuts));
         current_statement__ = 127;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, X_d_opencl__,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d_opencl__, X_d_opencl__, beta, cuts));
         current_statement__ = 128;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d_opencl__, X_p, beta, cuts));
         current_statement__ = 129;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d_opencl__, X_p, beta, cuts));
         current_statement__ = 130;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d_td_opencl__, X_d_td_opencl__, beta, cuts));
         current_statement__ = 131;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d_td_opencl__, X_d_td_opencl__, beta, cuts));
         current_statement__ = 132;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d_td_opencl__, X_p, beta, cuts));
         current_statement__ = 133;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(beta),
-                         stan::math::to_matrix_cl(cuts)));
+                         y_vi_d_td_opencl__, X_p, beta, cuts));
         current_statement__ = 134;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_vi_d,
-                         X_rv_d, beta, cuts));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
+                         y_vi_d_opencl__, X_rv_d_opencl__, beta, cuts));
         current_statement__ = 135;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_vi_d, X_rv_d, beta, cuts));
+                         y_vi_d_opencl__, X_rv_d_opencl__, beta, cuts));
         current_statement__ = 136;
-        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(y_vi_d,
-                         X_rv_p, beta, cuts));
+        lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<false>(
+                         y_vi_d_opencl__, X_rv_p, beta, cuts));
         current_statement__ = 137;
         lp_accum__.add(stan::math::ordered_logistic_glm_lpmf<propto__>(
-                         y_vi_d, X_rv_p, beta, cuts));
+                         y_vi_d_opencl__, X_rv_p, beta, cuts));
         current_statement__ = 138;
-        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(y_s_d,
-                         X_d_opencl__, stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
+                         y_s_d_opencl__, X_d_opencl__, alpha_v, beta_m));
         current_statement__ = 139;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_s_d, X_d_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_s_d_opencl__, X_d_opencl__, alpha_v, beta_m));
         current_statement__ = 140;
-        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(y_s_d,
-                         stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
+                         y_s_d_opencl__, X_p, alpha_v, beta_m));
         current_statement__ = 141;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_s_d, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_s_d_opencl__, X_p, alpha_v, beta_m));
         current_statement__ = 142;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_s_d_td, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_s_d_td_opencl__, X_d_td_opencl__, alpha_v, beta_m));
         current_statement__ = 143;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_s_d_td, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_s_d_td_opencl__, X_d_td_opencl__, alpha_v, beta_m));
         current_statement__ = 144;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_s_d_td_opencl__, X_p, alpha_v, beta_m));
         current_statement__ = 145;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_s_d_td, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_s_d_td_opencl__, X_p, alpha_v, beta_m));
         current_statement__ = 146;
-        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(y_s_d,
-                         X_rv_d, alpha_v, beta_m));
+        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
+                         y_s_d_opencl__, X_rv_d_opencl__, alpha_v, beta_m));
         current_statement__ = 147;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_s_d, X_rv_d, alpha_v, beta_m));
+                         y_s_d_opencl__, X_rv_d_opencl__, alpha_v, beta_m));
         current_statement__ = 148;
-        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(y_s_d,
-                         X_rv_p, alpha_v, beta_m));
+        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
+                         y_s_d_opencl__, X_rv_p, alpha_v, beta_m));
         current_statement__ = 149;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_s_d, X_rv_p, alpha_v, beta_m));
+                         y_s_d_opencl__, X_rv_p, alpha_v, beta_m));
         current_statement__ = 150;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_s_d_td, X_rv_d_td, alpha_v, beta_m));
+                         y_s_d_td_opencl__, X_rv_d_td_opencl__, alpha_v,
+                         beta_m));
         current_statement__ = 151;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_s_d_td, X_rv_d_td, alpha_v, beta_m));
+                         y_s_d_td_opencl__, X_rv_d_td_opencl__, alpha_v,
+                         beta_m));
         current_statement__ = 152;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_s_d_td, X_rv_p, alpha_v, beta_m));
+                         y_s_d_td_opencl__, X_rv_p, alpha_v, beta_m));
         current_statement__ = 153;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_s_d_td, X_rv_p, alpha_v, beta_m));
+                         y_s_d_td_opencl__, X_rv_p, alpha_v, beta_m));
         current_statement__ = 154;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_vi_d_opencl__, X_d_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d_opencl__, X_d_opencl__, alpha_v, beta_m));
         current_statement__ = 155;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, X_d_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d_opencl__, X_d_opencl__, alpha_v, beta_m));
         current_statement__ = 156;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d_opencl__, X_p, alpha_v, beta_m));
         current_statement__ = 157;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_vi_d_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d_opencl__, X_p, alpha_v, beta_m));
         current_statement__ = 158;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha_v, beta_m));
         current_statement__ = 159;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, X_d_td_opencl__,
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d_td_opencl__, X_d_td_opencl__, alpha_v, beta_m));
         current_statement__ = 160;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d_td_opencl__, X_p, alpha_v, beta_m));
         current_statement__ = 161;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_vi_d_td_opencl__, stan::math::to_matrix_cl(X_p),
-                         stan::math::to_matrix_cl(alpha_v),
-                         stan::math::to_matrix_cl(beta_m)));
+                         y_vi_d_td_opencl__, X_p, alpha_v, beta_m));
         current_statement__ = 162;
-        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(y_vi_d,
-                         X_rv_d, alpha_v, beta_m));
+        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
+                         y_vi_d_opencl__, X_rv_d_opencl__, alpha_v, beta_m));
         current_statement__ = 163;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_vi_d, X_rv_d, alpha_v, beta_m));
+                         y_vi_d_opencl__, X_rv_d_opencl__, alpha_v, beta_m));
         current_statement__ = 164;
-        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(y_vi_d,
-                         X_rv_p, alpha_v, beta_m));
+        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
+                         y_vi_d_opencl__, X_rv_p, alpha_v, beta_m));
         current_statement__ = 165;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_vi_d, X_rv_p, alpha_v, beta_m));
+                         y_vi_d_opencl__, X_rv_p, alpha_v, beta_m));
         current_statement__ = 166;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_vi_d_td, X_rv_d_td, alpha_v, beta_m));
+                         y_vi_d_td_opencl__, X_rv_d_td_opencl__, alpha_v,
+                         beta_m));
         current_statement__ = 167;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_vi_d_td, X_rv_d_td, alpha_v, beta_m));
+                         y_vi_d_td_opencl__, X_rv_d_td_opencl__, alpha_v,
+                         beta_m));
         current_statement__ = 168;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y_vi_d_td, X_rv_p, alpha_v, beta_m));
+                         y_vi_d_td_opencl__, X_rv_p, alpha_v, beta_m));
         current_statement__ = 169;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y_vi_d_td, X_rv_p, alpha_v, beta_m));
+                         y_vi_d_td_opencl__, X_rv_p, alpha_v, beta_m));
         current_statement__ = 170;
-        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(y2_vi_d,
-                         X_rv_p, alpha_v, beta_m));
+        lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
+                         y2_vi_d_opencl__, X_rv_p, alpha_v, beta_m));
         current_statement__ = 171;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y2_vi_d, X_rv_p, alpha_v, beta_m));
+                         y2_vi_d_opencl__, X_rv_p, alpha_v, beta_m));
         current_statement__ = 172;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<false>(
-                         y2_vi_d_td, X_rv_p, alpha_v, beta_m));
+                         y2_vi_d_td_opencl__, X_rv_p, alpha_v, beta_m));
         current_statement__ = 173;
         lp_accum__.add(stan::math::categorical_logit_glm_lpmf<propto__>(
-                         y2_vi_d_td, X_rv_p, alpha_v, beta_m));
+                         y2_vi_d_td_opencl__, X_rv_p, alpha_v, beta_m));
         current_statement__ = 174;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<false>(y_v_d_opencl__,
-                         stan::math::to_matrix_cl(
-                           stan::model::rvalue(X_d_a, "X_d_a",
-                             stan::model::index_uni(1))), alpha,
-                         stan::math::to_matrix_cl(beta), sigma));
+                         stan::model::rvalue(X_d_a_opencl__,
+                           "X_d_a_opencl__", stan::model::index_uni(1)),
+                         alpha, beta, sigma));
         current_statement__ = 175;
         lp_accum__.add(stan::math::normal_id_glm_lpdf<propto__>(
                          y_v_d_opencl__,
-                         stan::math::to_matrix_cl(
-                           stan::model::rvalue(X_d_a, "X_d_a",
-                             stan::model::index_uni(1))), alpha,
-                         stan::math::to_matrix_cl(beta), sigma));
+                         stan::model::rvalue(X_d_a_opencl__,
+                           "X_d_a_opencl__", stan::model::index_uni(1)),
+                         alpha, beta, sigma));
       }
-      X_d_opencl__.wait_for_read_write_events();
-      X_d_td_opencl__.wait_for_read_write_events();
-      y_v_d_opencl__.wait_for_read_write_events();
-      y_v_d_td_opencl__.wait_for_read_write_events();
-      y_vi_d_opencl__.wait_for_read_write_events();
-      y_vi_d_td_opencl__.wait_for_read_write_events();
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
     }
diff --git a/test/integration/good/code-gen/lir.expected b/test/integration/good/code-gen/lir.expected
index 061a723b0..488be73a7 100644
--- a/test/integration/good/code-gen/lir.expected
+++ b/test/integration/good/code-gen/lir.expected
@@ -4,11 +4,12 @@
  (Namespace mother_model_namespace
   ((GlobalUsing stan::model::model_base_crtp ()) (GlobalUsing "namespace stan::math" ())
    (GlobalVariableDefn
-    ((static false) (constexpr false) (type_ (TypeLiteral stan::math::profile_map))
+    ((static false) (constexpr false) (type_ (TypeLiteral stan::math::profile_map AoS))
      (name profiles__) (init Uninitialized)))
    (GlobalVariableDefn
     ((static true) (constexpr true)
-     (type_ (Array (Const (Pointer (TypeLiteral char))) 788)) (name locations_array__)
+     (type_ (Array (Const (Pointer (TypeLiteral char AoS))) 788 AoS))
+     (name locations_array__)
      (init
       (Assignment
        (ArrayLiteral
@@ -801,8 +802,10 @@
          (Literal "\" (in 'mother.stan', line 344, column 4 to column 16)\"")
          (Literal "\" (in 'mother.stan', line 341, column 41 to line 345, column 3)\"")))))))
    (FunDef
-    ((templates_init ((()) true)) (inline false) (return_type Int) (name foo)
-     (args (((Const (Ref Int)) n) ((Pointer (TypeLiteral std::ostream)) pstream__)))
+    ((templates_init ((()) true)) (inline false) (return_type (Int AoS)) 
+     (name foo)
+     (args
+      (((Const (Ref (Int AoS))) n) ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -814,18 +817,20 @@
      (return_type
       (StdVector
        (TypeTrait stan::promote_args_t
-        ((TemplateType T0__) (TemplateType T1__) (TemplateType T2__)))))
+        ((TemplateType T0__) (TemplateType T1__) (TemplateType T2__)))
+       AoS))
      (name sho)
      (args
       (((Const (Ref (TemplateType T0__))) t)
-       ((Const (Ref (StdVector (TemplateType T1__)))) y)
-       ((Const (Ref (StdVector (TemplateType T2__)))) theta)
-       ((Const (Ref (StdVector Double))) x) ((Const (Ref (StdVector Int))) x_int)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Const (Ref (StdVector (TemplateType T1__) AoS))) y)
+       ((Const (Ref (StdVector (TemplateType T2__) AoS))) theta)
+       ((Const (Ref (StdVector (Double AoS) AoS))) x)
+       ((Const (Ref (StdVector (Int AoS) AoS))) x_int)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
-    ((templates_init ((()) true)) (inline false) (return_type Double) 
-     (name foo_bar0) (args (((Pointer (TypeLiteral std::ostream)) pstream__)))
+    ((templates_init ((()) true)) (inline false) (return_type (Double AoS))
+     (name foo_bar0) (args (((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init ((((Typename T0__) (RequireIs stan::is_stan_scalar T0__))) true))
@@ -833,7 +838,7 @@
      (name foo_bar1)
      (args
       (((Const (Ref (TemplateType T0__))) x)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -846,7 +851,7 @@
      (name foo_bar2)
      (args
       (((Const (Ref (TemplateType T0__))) x) ((Const (Ref (TemplateType T1__))) y)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -854,24 +859,24 @@
      (inline false) (return_type (TypeTrait stan::promote_args_t ((TemplateType T1__))))
      (name foo_lpmf)
      (args
-      (((Const (Ref Int)) y) ((Const (Ref (TemplateType T1__))) lambda)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+      (((Const (Ref (Int AoS))) y) ((Const (Ref (TemplateType T1__))) lambda)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init ((((Typename T1__) (RequireIs stan::is_stan_scalar T1__))) true))
      (inline false) (return_type (TypeTrait stan::promote_args_t ((TemplateType T1__))))
      (name foo_lcdf)
      (args
-      (((Const (Ref Int)) y) ((Const (Ref (TemplateType T1__))) lambda)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+      (((Const (Ref (Int AoS))) y) ((Const (Ref (TemplateType T1__))) lambda)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init ((((Typename T1__) (RequireIs stan::is_stan_scalar T1__))) true))
      (inline false) (return_type (TypeTrait stan::promote_args_t ((TemplateType T1__))))
      (name foo_lccdf)
      (args
-      (((Const (Ref Int)) y) ((Const (Ref (TemplateType T1__))) lambda)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+      (((Const (Ref (Int AoS))) y) ((Const (Ref (TemplateType T1__))) lambda)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -885,7 +890,7 @@
      (args
       (((Const (Ref (TemplateType T0__))) mu) ((Const (Ref (TemplateType T1__))) sigma)
        ((Ref (TemplateType RNG)) base_rng__)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -896,24 +901,28 @@
      (args
       (((Const (Ref (TemplateType T0__))) u) ((Ref (TemplateType T_lp__)) lp__)
        ((Ref (TemplateType T_lp_accum__)) lp_accum__)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
-    ((templates_init ((()) true)) (inline false) (return_type Int) (name foo_1)
-     (args (((Const (Ref Int)) a) ((Pointer (TypeLiteral std::ostream)) pstream__)))
+    ((templates_init ((()) true)) (inline false) (return_type (Int AoS)) 
+     (name foo_1)
+     (args
+      (((Const (Ref (Int AoS))) a) ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
-    ((templates_init ((()) true)) (inline false) (return_type Int) (name foo_2)
-     (args (((Const (Ref Int)) a) ((Pointer (TypeLiteral std::ostream)) pstream__)))
+    ((templates_init ((()) true)) (inline false) (return_type (Int AoS)) 
+     (name foo_2)
+     (args
+      (((Const (Ref (Int AoS))) a) ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init ((((Typename T0__) (RequireIs stan::is_stan_scalar T0__))) true))
      (inline false)
-     (return_type (StdVector (TypeTrait stan::promote_args_t ((TemplateType T0__)))))
+     (return_type (StdVector (TypeTrait stan::promote_args_t ((TemplateType T0__))) AoS))
      (name foo_3)
      (args
-      (((Const (Ref (TemplateType T0__))) t) ((Const (Ref Int)) n)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+      (((Const (Ref (TemplateType T0__))) t) ((Const (Ref (Int AoS))) n)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -925,14 +934,14 @@
      (args
       (((Const (Ref (TemplateType T0__))) x) ((Ref (TemplateType T_lp__)) lp__)
        ((Ref (TemplateType T_lp_accum__)) lp_accum__)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init ((((Typename T0__) (RequireIs stan::is_stan_scalar T0__))) true))
      (inline false) (return_type Void) (name foo_4)
      (args
-      (((Const (Ref (StdVector (TemplateType T0__)))) x)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+      (((Const (Ref (StdVector (TemplateType T0__) AoS))) x)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -948,7 +957,7 @@
      (args
       (((Const (Ref (TemplateType T0__))) x) ((Const (Ref (TemplateType T1__))) y)
        ((Const (Ref (TemplateType T2__))) max_) ((Const (Ref (TemplateType T3__))) min_)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -966,8 +975,9 @@
      (args
       (((Const (Ref (TemplateType T0__))) shared_params_arg__)
        ((Const (Ref (TemplateType T1__))) job_params_arg__)
-       ((Const (Ref (StdVector Double))) data_r) ((Const (Ref (StdVector Int))) data_i)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Const (Ref (StdVector (Double AoS) AoS))) data_r)
+       ((Const (Ref (StdVector (Int AoS) AoS))) data_i)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -986,7 +996,7 @@
       (((Const (Ref (TemplateType T0__))) x1) ((Const (Ref (TemplateType T1__))) x2)
        ((Const (Ref (TemplateType T2__))) x3) ((Const (Ref (TemplateType T3__))) x4)
        ((Const (Ref (TemplateType T4__))) x5)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1008,7 +1018,7 @@
        ((Const (Ref (TemplateType T2__))) x3) ((Const (Ref (TemplateType T3__))) x4)
        ((Const (Ref (TemplateType T4__))) x5) ((Const (Ref (TemplateType T5__))) x6)
        ((Ref (TemplateType T_lp__)) lp__) ((Ref (TemplateType T_lp_accum__)) lp_accum__)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1021,8 +1031,8 @@
        -1 -1 AoS))
      (name covsqrt2corsqrt)
      (args
-      (((Const (Ref (TemplateType T0__))) mat_arg__) ((Const (Ref Int)) invert)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+      (((Const (Ref (TemplateType T0__))) mat_arg__) ((Const (Ref (Int AoS))) invert)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1038,19 +1048,22 @@
        true))
      (inline false) (return_type Void) (name f0)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1064,21 +1077,24 @@
          (RequireIs stan::is_vt_not_complex T9__) (RequireIs stan::is_stan_scalar T10__)
          (RequireIs stan::is_stan_scalar T11__)))
        true))
-     (inline false) (return_type Int) (name f1)
+     (inline false) (return_type (Int AoS)) (name f1)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1092,21 +1108,24 @@
          (RequireIs stan::is_vt_not_complex T9__) (RequireIs stan::is_stan_scalar T10__)
          (RequireIs stan::is_stan_scalar T11__)))
        true))
-     (inline false) (return_type (StdVector Int)) (name f2)
+     (inline false) (return_type (StdVector (Int AoS) AoS)) (name f2)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1120,21 +1139,25 @@
          (RequireIs stan::is_vt_not_complex T9__) (RequireIs stan::is_stan_scalar T10__)
          (RequireIs stan::is_stan_scalar T11__)))
        true))
-     (inline false) (return_type (StdVector (StdVector Int))) (name f3)
+     (inline false) (return_type (StdVector (StdVector (Int AoS) AoS) AoS)) 
+     (name f3)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1158,19 +1181,22 @@
           (TemplateType T10__) (TemplateType T11__))))))
      (name f4)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1192,22 +1218,26 @@
          (TemplateType stan::base_type_t<T6__>) (TemplateType T7__)
          (TypeTrait stan::promote_args_t
           ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
-           (TemplateType T10__) (TemplateType T11__)))))))
+           (TemplateType T10__) (TemplateType T11__)))))
+       AoS))
      (name f5)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1230,22 +1260,27 @@
           (TemplateType stan::base_type_t<T6__>) (TemplateType T7__)
           (TypeTrait stan::promote_args_t
            ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
-            (TemplateType T10__) (TemplateType T11__))))))))
+            (TemplateType T10__) (TemplateType T11__)))))
+        AoS)
+       AoS))
      (name f6)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1271,19 +1306,22 @@
        -1 1 AoS))
      (name f7)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1307,22 +1345,26 @@
           (TypeTrait stan::promote_args_t
            ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
             (TemplateType T10__) (TemplateType T11__)))))
-        -1 1 AoS)))
+        -1 1 AoS)
+       AoS))
      (name f8)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1347,22 +1389,27 @@
            (TypeTrait stan::promote_args_t
             ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
              (TemplateType T10__) (TemplateType T11__)))))
-         -1 1 AoS))))
+         -1 1 AoS)
+        AoS)
+       AoS))
      (name f9)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1388,19 +1435,22 @@
        -1 -1 AoS))
      (name f10)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1424,22 +1474,26 @@
           (TypeTrait stan::promote_args_t
            ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
             (TemplateType T10__) (TemplateType T11__)))))
-        -1 -1 AoS)))
+        -1 -1 AoS)
+       AoS))
      (name f11)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1464,35 +1518,42 @@
            (TypeTrait stan::promote_args_t
             ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
              (TemplateType T10__) (TemplateType T11__)))))
-         -1 -1 AoS))))
+         -1 -1 AoS)
+        AoS)
+       AoS))
      (name f12)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init ((()) true)) (inline false) (return_type Void) (name foo_6)
-     (args (((Pointer (TypeLiteral std::ostream)) pstream__))) (cv_qualifiers ())
+     (args (((Pointer (TypeLiteral std::ostream AoS)) pstream__))) (cv_qualifiers ())
      (body ())))
    (FunDef
-    ((templates_init ((()) true)) (inline false) (return_type (Matrix Double -1 -1 AoS))
-     (name matfoo) (args (((Pointer (TypeLiteral std::ostream)) pstream__)))
-     (cv_qualifiers ()) (body ())))
+    ((templates_init ((()) true)) (inline false)
+     (return_type (Matrix (Double AoS) -1 -1 AoS)) (name matfoo)
+     (args (((Pointer (TypeLiteral std::ostream AoS)) pstream__))) (cv_qualifiers ())
+     (body ())))
    (FunDef
-    ((templates_init ((()) true)) (inline false) (return_type (Matrix Double -1 1 AoS))
-     (name vecfoo) (args (((Pointer (TypeLiteral std::ostream)) pstream__)))
-     (cv_qualifiers ()) (body ())))
+    ((templates_init ((()) true)) (inline false)
+     (return_type (Matrix (Double AoS) -1 1 AoS)) (name vecfoo)
+     (args (((Pointer (TypeLiteral std::ostream AoS)) pstream__))) (cv_qualifiers ())
+     (body ())))
    (FunDef
     ((templates_init ((((Typename T0__) (RequireIs stan::is_stan_scalar T0__))) true))
      (inline false)
@@ -1501,7 +1562,7 @@
      (name vecmufoo)
      (args
       (((Const (Ref (TemplateType T0__))) mu)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init ((((Typename T0__) (RequireIs stan::is_stan_scalar T0__))) true))
@@ -1511,7 +1572,7 @@
      (name vecmubar)
      (args
       (((Const (Ref (TemplateType T0__))) mu)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1531,9 +1592,9 @@
      (args
       (((Const (Ref (TemplateType T0__))) x_arg__)
        ((Const (Ref (TemplateType T1__))) y_arg__)
-       ((Const (Ref (StdVector (TemplateType T2__)))) dat)
-       ((Const (Ref (StdVector Int))) dat_int)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Const (Ref (StdVector (TemplateType T2__) AoS))) dat)
+       ((Const (Ref (StdVector (Int AoS) AoS))) dat_int)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (FunDef
     ((templates_init
@@ -1551,8 +1612,9 @@
      (args
       (((Const (Ref (TemplateType T0__))) phi_arg__)
        ((Const (Ref (TemplateType T1__))) theta_arg__)
-       ((Const (Ref (StdVector Double))) x_r) ((Const (Ref (StdVector Int))) x_i)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Const (Ref (StdVector (Double AoS) AoS))) x_r)
+       ((Const (Ref (StdVector (Int AoS) AoS))) x_i)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ()) (body ())))
    (Struct
     ((param ()) (struct_name algebra_system_functor__)
@@ -1576,9 +1638,9 @@
          (name "operator()")
          (args
           (((Const (Ref (TemplateType T0__))) x) ((Const (Ref (TemplateType T1__))) y)
-           ((Const (Ref (StdVector (TemplateType T2__)))) dat)
-           ((Const (Ref (StdVector Int))) dat_int)
-           ((Pointer (TypeLiteral std::ostream)) pstream__)))
+           ((Const (Ref (StdVector (TemplateType T2__) AoS))) dat)
+           ((Const (Ref (StdVector (Int AoS) AoS))) dat_int)
+           ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
          (cv_qualifiers (Const))
          (body
           (((Return
@@ -1605,28 +1667,31 @@
          (args
           (((Const (Ref (TemplateType T0__))) phi)
            ((Const (Ref (TemplateType T1__))) theta)
-           ((Const (Ref (StdVector Double))) x_r) ((Const (Ref (StdVector Int))) x_i)
-           ((Pointer (TypeLiteral std::ostream)) pstream__)))
+           ((Const (Ref (StdVector (Double AoS) AoS))) x_r)
+           ((Const (Ref (StdVector (Int AoS) AoS))) x_i)
+           ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
          (cv_qualifiers (Const))
          (body
           (((Return
              ((FunCall binomialf ()
                ((Var phi) (Var theta) (Var x_r) (Var x_i) (Var pstream__))))))))))))))
    (FunDef
-    ((templates_init ((()) false)) (inline false) (return_type Int) (name foo)
-     (args (((Const (Ref Int)) n) ((Pointer (TypeLiteral std::ostream)) pstream__)))
+    ((templates_init ((()) false)) (inline false) (return_type (Int AoS)) 
+     (name foo)
+     (args
+      (((Const (Ref (Int AoS))) n) ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
-      (((Using local_scalar_t__ (Double))
+      (((Using local_scalar_t__ ((Double AoS)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -1644,7 +1709,7 @@
              (BinOp (Var n) Multiply
               (FunCall foo ()
                ((Parens (BinOp (Var n) Subtract (Literal 1))) (Var pstream__))))))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -1658,28 +1723,30 @@
      (return_type
       (StdVector
        (TypeTrait stan::promote_args_t
-        ((TemplateType T0__) (TemplateType T1__) (TemplateType T2__)))))
+        ((TemplateType T0__) (TemplateType T1__) (TemplateType T2__)))
+       AoS))
      (name sho)
      (args
       (((Const (Ref (TemplateType T0__))) t)
-       ((Const (Ref (StdVector (TemplateType T1__)))) y)
-       ((Const (Ref (StdVector (TemplateType T2__)))) theta)
-       ((Const (Ref (StdVector Double))) x) ((Const (Ref (StdVector Int))) x_int)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Const (Ref (StdVector (TemplateType T1__) AoS))) y)
+       ((Const (Ref (StdVector (TemplateType T2__) AoS))) theta)
+       ((Const (Ref (StdVector (Double AoS) AoS))) x)
+       ((Const (Ref (StdVector (Int AoS) AoS))) x_int)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
          ((TypeTrait stan::promote_args_t
            ((TemplateType T0__) (TemplateType T1__) (TemplateType T2__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -1687,10 +1754,11 @@
         (TryCatch
          ((VariableDefn
            ((static false) (constexpr false)
-            (type_ (StdVector (TypeLiteral local_scalar_t__))) (name dydt)
+            (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)) 
+            (name dydt)
             (init
              (Assignment
-              (Constructor (StdVector (TypeLiteral local_scalar_t__))
+              (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                ((Literal 2) (Var DUMMY_VAR__)))))))
           (Expression (Assign (Var current_statement__) (Literal 598)))
           (Expression
@@ -1725,25 +1793,25 @@
              (FunCall stan::model::index_uni () ((Literal 2))))))
           (Expression (Assign (Var current_statement__) (Literal 600)))
           (Return ((Var dydt))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
    (FunDef
-    ((templates_init ((()) false)) (inline false) (return_type Double) 
-     (name foo_bar0) (args (((Pointer (TypeLiteral std::ostream)) pstream__)))
+    ((templates_init ((()) false)) (inline false) (return_type (Double AoS))
+     (name foo_bar0) (args (((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
-      (((Using local_scalar_t__ (Double))
+      (((Using local_scalar_t__ ((Double AoS)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -1751,7 +1819,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 602)))
           (Return ((Literal 0.0))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -1761,19 +1829,19 @@
      (name foo_bar1)
      (args
       (((Const (Ref (TemplateType T0__))) x)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__ ((TypeTrait stan::promote_args_t ((TemplateType T0__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -1781,7 +1849,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 604)))
           (Return ((Literal 1.0))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -1796,20 +1864,20 @@
      (name foo_bar2)
      (args
       (((Const (Ref (TemplateType T0__))) x) ((Const (Ref (TemplateType T1__))) y)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
          ((TypeTrait stan::promote_args_t ((TemplateType T0__) (TemplateType T1__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -1817,7 +1885,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 606)))
           (Return ((Literal 2.0))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -1827,16 +1895,16 @@
      (inline false) (return_type (TypeTrait stan::promote_args_t ((TemplateType T1__))))
      (name foo_lpmf)
      (args
-      (((Const (Ref Int)) y) ((Const (Ref (TemplateType T1__))) lambda)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+      (((Const (Ref (Int AoS))) y) ((Const (Ref (TemplateType T1__))) lambda)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__ ((TypeTrait stan::promote_args_t ((TemplateType T1__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -1844,7 +1912,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 608)))
           (Return ((Literal 1.0))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -1853,20 +1921,20 @@
      (inline false) (return_type (TypeTrait stan::promote_args_t ((TemplateType T1__))))
      (name foo_lcdf)
      (args
-      (((Const (Ref Int)) y) ((Const (Ref (TemplateType T1__))) lambda)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+      (((Const (Ref (Int AoS))) y) ((Const (Ref (TemplateType T1__))) lambda)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__ ((TypeTrait stan::promote_args_t ((TemplateType T1__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -1874,7 +1942,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 610)))
           (Return ((Literal 1.0))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -1883,20 +1951,20 @@
      (inline false) (return_type (TypeTrait stan::promote_args_t ((TemplateType T1__))))
      (name foo_lccdf)
      (args
-      (((Const (Ref Int)) y) ((Const (Ref (TemplateType T1__))) lambda)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+      (((Const (Ref (Int AoS))) y) ((Const (Ref (TemplateType T1__))) lambda)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__ ((TypeTrait stan::promote_args_t ((TemplateType T1__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -1904,7 +1972,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 612)))
           (Return ((Literal 1.0))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -1920,20 +1988,20 @@
      (args
       (((Const (Ref (TemplateType T0__))) mu) ((Const (Ref (TemplateType T1__))) sigma)
        ((Ref (TemplateType RNG)) base_rng__)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
          ((TypeTrait stan::promote_args_t ((TemplateType T0__) (TemplateType T1__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -1942,7 +2010,7 @@
          ((Expression (Assign (Var current_statement__) (Literal 614)))
           (Return
            ((FunCall stan::math::normal_rng () ((Var mu) (Var sigma) (Var base_rng__))))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -1955,15 +2023,15 @@
      (args
       (((Const (Ref (TemplateType T0__))) u) ((Ref (TemplateType T_lp__)) lp__)
        ((Ref (TemplateType T_lp_accum__)) lp_accum__)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__ ((TypeTrait stan::promote_args_t ((TemplateType T0__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -1979,25 +2047,27 @@
            (MethodCall (Var lp_accum__) add ()
             ((FunCall stan::math::uniform_lpdf ((TemplateType propto__))
               ((Var u) (PMinus (Literal 100)) (Literal 100)))))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
    (FunDef
-    ((templates_init ((()) false)) (inline false) (return_type Int) (name foo_1)
-     (args (((Const (Ref Int)) a) ((Pointer (TypeLiteral std::ostream)) pstream__)))
+    ((templates_init ((()) false)) (inline false) (return_type (Int AoS)) 
+     (name foo_1)
+     (args
+      (((Const (Ref (Int AoS))) a) ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
-      (((Using local_scalar_t__ (Double))
+      (((Using local_scalar_t__ ((Double AoS)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -2009,19 +2079,19 @@
           (While (Literal 0) (Block (Continue)))
           (Expression (Assign (Var current_statement__) (Literal 624)))
           (For
-           ((static false) (constexpr false) (type_ Int) (name i)
+           ((static false) (constexpr false) (type_ (Int AoS)) (name i)
             (init (Assignment (Literal 1))))
            (BinOp (Var i) LEq (Literal 10)) (Increment (Var i)) (Block (Break)))
           (Expression (Assign (Var current_statement__) (Literal 626)))
           (For
-           ((static false) (constexpr false) (type_ Int) (name i)
+           ((static false) (constexpr false) (type_ (Int AoS)) (name i)
             (init (Assignment (Literal 1))))
            (BinOp (Var i) LEq (Literal 10)) (Increment (Var i)) (Block (Continue)))
           (Expression (Assign (Var current_statement__) (Literal 631)))
           (While (Literal 1)
            (Block
             ((VariableDefn
-              ((static false) (constexpr false) (type_ Int) (name b)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name b)
                (init (Assignment (FunCall std::numeric_limits<int>::min () ())))))
              (Expression (Assign (Var current_statement__) (Literal 628)))
              (Expression (Assign (Var b) (Literal 5))) Break)))
@@ -2043,33 +2113,33 @@
            (Block
             ((Expression (Assign (Var current_statement__) (Literal 643)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name i)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name i)
                (init (Assignment (Literal 1))))
               (BinOp (Var i) LEq (Literal 10)) (Increment (Var i)) (Block (Break))))))
           (Expression (Assign (Var current_statement__) (Literal 660)))
           (While (Literal 1)
            (Block
             ((VariableDefn
-              ((static false) (constexpr false) (type_ (StdVector (StdVector Int)))
-               (name vs)
+              ((static false) (constexpr false)
+               (type_ (StdVector (StdVector (Int AoS) AoS) AoS)) (name vs)
                (init
                 (Assignment
-                 (Constructor (StdVector (StdVector Int))
+                 (Constructor (StdVector (StdVector (Int AoS) AoS) AoS)
                   ((Literal 2)
-                   (Constructor (StdVector Int)
+                   (Constructor (StdVector (Int AoS) AoS)
                     ((Literal 3) (FunCall std::numeric_limits<int>::min () ())))))))))
              (VariableDefn
-              ((static false) (constexpr false) (type_ Int) (name z)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name z)
                (init (Assignment (FunCall std::numeric_limits<int>::min () ())))))
              (Expression (Assign (Var current_statement__) (Literal 648)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (FunCall stan::math::size () ((Var vs))))
               (Increment (Var sym1__))
               (Block
                ((VariableDefn
-                 ((static false) (constexpr false) (type_ (StdVector Int)) 
+                 ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
                   (name v) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 648)))
                 (Expression
@@ -2081,13 +2151,13 @@
                 (Expression (Assign (Var z) (Literal 0))) Break)))
              (Expression (Assign (Var current_statement__) (Literal 651)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (FunCall stan::math::size () ((Var vs))))
               (Increment (Var sym1__))
               (Block
                ((VariableDefn
-                 ((static false) (constexpr false) (type_ (StdVector Int)) 
+                 ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
                   (name v) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 651)))
                 (Expression
@@ -2099,13 +2169,13 @@
                 (Expression (Assign (Var z) (Literal 0))) Continue)))
              (Expression (Assign (Var current_statement__) (Literal 654)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (FunCall stan::math::size () ((Var vs))))
               (Increment (Var sym1__))
               (Block
                ((VariableDefn
-                 ((static false) (constexpr false) (type_ (StdVector Int)) 
+                 ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
                   (name v) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 654)))
                 (Expression
@@ -2115,14 +2185,14 @@
                    (Literal "\"assigning variable v\""))))
                 (Expression (Assign (Var current_statement__) (Literal 655)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (FunCall stan::math::size () ((Var v))))
                  (Increment (Var sym1__))
                  (Block
                   ((VariableDefn
-                    ((static false) (constexpr false) (type_ Int) (name vv)
-                     (init Uninitialized)))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name vv) (init Uninitialized)))
                    (Expression (Assign (Var current_statement__) (Literal 655)))
                    (Expression
                     (Assign (Var vv)
@@ -2135,27 +2205,28 @@
           (While (Literal 1)
            (Block
             ((VariableDefn
-              ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-               (name z) (init (Assignment (Var DUMMY_VAR__)))))
+              ((static false) (constexpr false)
+               (type_ (TypeLiteral local_scalar_t__ AoS)) (name z)
+               (init (Assignment (Var DUMMY_VAR__)))))
              (VariableDefn
               ((static false) (constexpr false)
-               (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)) 
+               (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)) 
                (name vs)
                (init
                 (Assignment
-                 (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                 (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                   Constant () ((Literal 2) (Literal 3) (Var DUMMY_VAR__)))))))
              (Expression (Assign (Var current_statement__) (Literal 663)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (FunCall stan::math::rows () ((Var vs))))
               (Increment (Var sym1__))
               (Block
                ((Expression (Assign (Var current_statement__) (Literal 663)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq
                   (FunCall stan::math::size ()
                    ((FunCall stan::model::rvalue ()
@@ -2165,7 +2236,7 @@
                  (Block
                   ((VariableDefn
                     ((static false) (constexpr false)
-                     (type_ (TypeLiteral local_scalar_t__)) (name v)
+                     (type_ (TypeLiteral local_scalar_t__ AoS)) (name v)
                      (init Uninitialized)))
                    (Expression (Assign (Var current_statement__) (Literal 663)))
                    (Expression
@@ -2178,15 +2249,15 @@
                    (Expression (Assign (Var z) (Literal 0))) Break))))))
              (Expression (Assign (Var current_statement__) (Literal 666)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (FunCall stan::math::rows () ((Var vs))))
               (Increment (Var sym1__))
               (Block
                ((Expression (Assign (Var current_statement__) (Literal 666)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq
                   (FunCall stan::math::size ()
                    ((FunCall stan::model::rvalue ()
@@ -2196,7 +2267,7 @@
                  (Block
                   ((VariableDefn
                     ((static false) (constexpr false)
-                     (type_ (TypeLiteral local_scalar_t__)) (name v)
+                     (type_ (TypeLiteral local_scalar_t__ AoS)) (name v)
                      (init Uninitialized)))
                    (Expression (Assign (Var current_statement__) (Literal 666)))
                    (Expression
@@ -2211,26 +2282,28 @@
           (While (Literal 1)
            (Block
             ((VariableDefn
-              ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-               (name z) (init (Assignment (Var DUMMY_VAR__)))))
+              ((static false) (constexpr false)
+               (type_ (TypeLiteral local_scalar_t__ AoS)) (name z)
+               (init (Assignment (Var DUMMY_VAR__)))))
              (VariableDefn
               ((static false) (constexpr false)
-               (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+               (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                (name vs)
                (init
                 (Assignment
-                 (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                 (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                   Constant () ((Literal 2) (Var DUMMY_VAR__)))))))
              (Expression (Assign (Var current_statement__) (Literal 673)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (FunCall stan::math::size () ((Var vs))))
               (Increment (Var sym1__))
               (Block
                ((VariableDefn
-                 ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                  (name v) (init Uninitialized)))
+                 ((static false) (constexpr false)
+                  (type_ (TypeLiteral local_scalar_t__ AoS)) (name v)
+                  (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 673)))
                 (Expression
                  (Assign (Var v)
@@ -2239,14 +2312,15 @@
                 (Expression (Assign (Var z) (Literal 0))) Break)))
              (Expression (Assign (Var current_statement__) (Literal 676)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (FunCall stan::math::size () ((Var vs))))
               (Increment (Var sym1__))
               (Block
                ((VariableDefn
-                 ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                  (name v) (init Uninitialized)))
+                 ((static false) (constexpr false)
+                  (type_ (TypeLiteral local_scalar_t__ AoS)) (name v)
+                  (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 676)))
                 (Expression
                  (Assign (Var v)
@@ -2257,26 +2331,28 @@
           (While (Literal 1)
            (Block
             ((VariableDefn
-              ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-               (name z) (init (Assignment (Var DUMMY_VAR__)))))
+              ((static false) (constexpr false)
+               (type_ (TypeLiteral local_scalar_t__ AoS)) (name z)
+               (init (Assignment (Var DUMMY_VAR__)))))
              (VariableDefn
               ((static false) (constexpr false)
-               (type_ (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)) 
+               (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)) 
                (name vs)
                (init
                 (Assignment
-                 (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
+                 (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
                   Constant () ((Literal 2) (Var DUMMY_VAR__)))))))
              (Expression (Assign (Var current_statement__) (Literal 683)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (FunCall stan::math::size () ((Var vs))))
               (Increment (Var sym1__))
               (Block
                ((VariableDefn
-                 ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                  (name v) (init Uninitialized)))
+                 ((static false) (constexpr false)
+                  (type_ (TypeLiteral local_scalar_t__ AoS)) (name v)
+                  (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 683)))
                 (Expression
                  (Assign (Var v)
@@ -2285,14 +2361,15 @@
                 (Expression (Assign (Var z) (Literal 0))) Break)))
              (Expression (Assign (Var current_statement__) (Literal 686)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (FunCall stan::math::size () ((Var vs))))
               (Increment (Var sym1__))
               (Block
                ((VariableDefn
-                 ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                  (name v) (init Uninitialized)))
+                 ((static false) (constexpr false)
+                  (type_ (TypeLiteral local_scalar_t__ AoS)) (name v)
+                  (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 686)))
                 (Expression
                  (Assign (Var v)
@@ -2303,61 +2380,63 @@
           (While (Literal 1)
            (Block
             ((VariableDefn
-              ((static false) (constexpr false) (type_ Int) (name b)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name b)
                (init (Assignment (FunCall std::numeric_limits<int>::min () ())))))
              (Expression (Assign (Var current_statement__) (Literal 692)))
              (Expression (Assign (Var b) (Literal 5)))
              (Block
               ((VariableDefn
-                ((static false) (constexpr false) (type_ Int) (name c)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name c)
                  (init (Assignment (FunCall std::numeric_limits<int>::min () ())))))
                (Expression (Assign (Var current_statement__) (Literal 694)))
                (Expression (Assign (Var c) (Literal 6))) Break)))))
           (Expression (Assign (Var current_statement__) (Literal 699)))
           (Return ((Literal 0))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
    (FunDef
-    ((templates_init ((()) false)) (inline false) (return_type Int) (name foo_2)
-     (args (((Const (Ref Int)) a) ((Pointer (TypeLiteral std::ostream)) pstream__)))
+    ((templates_init ((()) false)) (inline false) (return_type (Int AoS)) 
+     (name foo_2)
+     (args
+      (((Const (Ref (Int AoS))) a) ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
-      (((Using local_scalar_t__ (Double))
+      (((Using local_scalar_t__ ((Double AoS)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
         (Expression (Cast Void (Var DUMMY_VAR__)))
         (TryCatch
          ((VariableDefn
-           ((static false) (constexpr false) (type_ (StdVector Int)) 
+           ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS)) 
             (name vs)
             (init
              (Assignment
-              (Constructor (StdVector Int)
+              (Constructor (StdVector (Int AoS) AoS)
                ((Literal 2) (FunCall std::numeric_limits<int>::min () ())))))))
           (VariableDefn
-           ((static false) (constexpr false) (type_ Int) (name y)
+           ((static false) (constexpr false) (type_ (Int AoS)) (name y)
             (init (Assignment (FunCall std::numeric_limits<int>::min () ())))))
           (Expression (Assign (Var current_statement__) (Literal 703)))
           (For
-           ((static false) (constexpr false) (type_ Int) (name sym1__)
+           ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
             (init (Assignment (Literal 1))))
            (BinOp (Var sym1__) LEq (FunCall stan::math::size () ((Var vs))))
            (Increment (Var sym1__))
            (Block
             ((VariableDefn
-              ((static false) (constexpr false) (type_ Int) (name v)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name v)
                (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 703)))
              (Expression
@@ -2367,30 +2446,30 @@
              (Expression (Assign (Var y) (Var v))))))
           (Expression (Assign (Var current_statement__) (Literal 705)))
           (Return ((Literal 0))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
    (FunDef
     ((templates_init ((((Typename T0__) (RequireIs stan::is_stan_scalar T0__))) false))
      (inline false)
-     (return_type (StdVector (TypeTrait stan::promote_args_t ((TemplateType T0__)))))
+     (return_type (StdVector (TypeTrait stan::promote_args_t ((TemplateType T0__))) AoS))
      (name foo_3)
      (args
-      (((Const (Ref (TemplateType T0__))) t) ((Const (Ref Int)) n)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+      (((Const (Ref (TemplateType T0__))) t) ((Const (Ref (Int AoS))) n)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__ ((TypeTrait stan::promote_args_t ((TemplateType T0__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -2398,7 +2477,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 707)))
           (Return ((FunCall stan::math::rep_array () ((Var t) (Var n))))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -2412,15 +2491,15 @@
      (args
       (((Const (Ref (TemplateType T0__))) x) ((Ref (TemplateType T_lp__)) lp__)
        ((Ref (TemplateType T_lp_accum__)) lp_accum__)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__ ((TypeTrait stan::promote_args_t ((TemplateType T0__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -2431,7 +2510,7 @@
            ((Parens
              (BinOp (Var x) Add
               (FunCall stan::math::get_lp () ((Var lp__) (Var lp_accum__))))))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -2439,20 +2518,20 @@
     ((templates_init ((((Typename T0__) (RequireIs stan::is_stan_scalar T0__))) false))
      (inline false) (return_type Void) (name foo_4)
      (args
-      (((Const (Ref (StdVector (TemplateType T0__)))) x)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+      (((Const (Ref (StdVector (TemplateType T0__) AoS))) x)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__ ((TypeTrait stan::promote_args_t ((TemplateType T0__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -2460,7 +2539,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 711)))
           (VariableDefn
-           ((static false) (constexpr false) (type_ (TypeLiteral std::stringstream))
+           ((static false) (constexpr false) (type_ (TypeLiteral std::stringstream AoS))
             (name errmsg_stream__) (init Uninitialized)))
           (Expression
            (FunCall stan::math::stan_print ()
@@ -2478,7 +2557,7 @@
            (FunCall stan::math::stan_print () ((VarRef errmsg_stream__) (Var x))))
           (Throw
            (FunCall std::domain_error () ((MethodCall (Var errmsg_stream__) str () ())))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -2496,7 +2575,7 @@
      (args
       (((Const (Ref (TemplateType T0__))) x) ((Const (Ref (TemplateType T1__))) y)
        ((Const (Ref (TemplateType T2__))) max_) ((Const (Ref (TemplateType T3__))) min_)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -2504,24 +2583,24 @@
            ((TemplateType T0__) (TemplateType T1__) (TemplateType T2__)
             (TemplateType T3__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
         (Expression (Cast Void (Var DUMMY_VAR__)))
         (TryCatch
          ((VariableDefn
-           ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+           ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
             (name abs_diff) (init (Assignment (Var DUMMY_VAR__)))))
           (VariableDefn
-           ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+           ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
             (name avg_scale) (init (Assignment (Var DUMMY_VAR__)))))
           (Expression (Assign (Var current_statement__) (Literal 715)))
           (Expression
@@ -2543,8 +2622,9 @@
            (Block
             ((Expression (Assign (Var current_statement__) (Literal 717)))
              (VariableDefn
-              ((static false) (constexpr false) (type_ (TypeLiteral std::stringstream))
-               (name errmsg_stream__) (init Uninitialized)))
+              ((static false) (constexpr false)
+               (type_ (TypeLiteral std::stringstream AoS)) (name errmsg_stream__)
+               (init Uninitialized)))
              (Expression
               (FunCall stan::math::stan_print ()
                ((VarRef errmsg_stream__)
@@ -2572,8 +2652,9 @@
            (Block
             ((Expression (Assign (Var current_statement__) (Literal 719)))
              (VariableDefn
-              ((static false) (constexpr false) (type_ (TypeLiteral std::stringstream))
-               (name errmsg_stream__) (init Uninitialized)))
+              ((static false) (constexpr false)
+               (type_ (TypeLiteral std::stringstream AoS)) (name errmsg_stream__)
+               (init Uninitialized)))
              (Expression
               (FunCall stan::math::stan_print ()
                ((VarRef errmsg_stream__)
@@ -2596,7 +2677,7 @@
            ())
           (Expression (Assign (Var current_statement__) (Literal 721)))
           (Return ((Parens (BinOp (Var abs_diff) Divide (Var avg_scale))))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -2616,8 +2697,9 @@
      (args
       (((Const (Ref (TemplateType T0__))) shared_params_arg__)
        ((Const (Ref (TemplateType T1__))) job_params_arg__)
-       ((Const (Ref (StdVector Double))) data_r) ((Const (Ref (StdVector Int))) data_i)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Const (Ref (StdVector (Double AoS) AoS))) data_r)
+       ((Const (Ref (StdVector (Int AoS) AoS))) data_i)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -2625,7 +2707,7 @@
            ((TemplateType stan::base_type_t<T0__>)
             (TemplateType stan::base_type_t<T1__>)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto)))
@@ -2636,11 +2718,11 @@
           (name job_params)
           (init (Assignment (FunCall stan::math::to_ref () ((Var job_params_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -2648,13 +2730,14 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 723)))
           (Return
-           ((FunCall stan::math::promote_scalar ((TypeLiteral local_scalar_t__))
+           ((FunCall stan::math::promote_scalar ((TypeLiteral local_scalar_t__ AoS))
              ((MethodCall
                (Parens
-                (StreamInsertion (Constructor (Matrix Double -1 1 AoS) ((Literal 3)))
+                (StreamInsertion
+                 (Constructor (Matrix (Double AoS) -1 1 AoS) ((Literal 3)))
                  ((Literal 1) (Literal 2) (Literal 3))))
                finished () ()))))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -2675,7 +2758,7 @@
       (((Const (Ref (TemplateType T0__))) x1) ((Const (Ref (TemplateType T1__))) x2)
        ((Const (Ref (TemplateType T2__))) x3) ((Const (Ref (TemplateType T3__))) x4)
        ((Const (Ref (TemplateType T4__))) x5)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -2683,14 +2766,14 @@
            ((TemplateType T0__) (TemplateType T1__) (TemplateType T2__)
             (TemplateType T3__) (TemplateType T4__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -2698,7 +2781,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 725)))
           (Return ((Var x1))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -2722,7 +2805,7 @@
        ((Const (Ref (TemplateType T2__))) x3) ((Const (Ref (TemplateType T3__))) x4)
        ((Const (Ref (TemplateType T4__))) x5) ((Const (Ref (TemplateType T5__))) x6)
        ((Ref (TemplateType T_lp__)) lp__) ((Ref (TemplateType T_lp_accum__)) lp_accum__)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -2731,10 +2814,10 @@
             (TemplateType T3__) (TemplateType T4__)
             (TypeTrait stan::promote_args_t ((TemplateType T5__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -2742,7 +2825,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 727)))
           (Return ((Var x1))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -2757,25 +2840,25 @@
        -1 -1 AoS))
      (name covsqrt2corsqrt)
      (args
-      (((Const (Ref (TemplateType T0__))) mat_arg__) ((Const (Ref Int)) invert)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+      (((Const (Ref (TemplateType T0__))) mat_arg__) ((Const (Ref (Int AoS))) invert)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
          ((TypeTrait stan::promote_args_t ((TemplateType stan::base_type_t<T0__>)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
           (name mat)
           (init (Assignment (FunCall stan::math::to_ref () ((Var mat_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -2793,11 +2876,11 @@
              (FunCall stan::math::cols () ((Var mat))))))
           (VariableDefn
            ((static false) (constexpr false)
-            (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)) 
+            (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)) 
             (name o)
             (init
              (Assignment
-              (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+              (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                Constant ()
                ((FunCall stan::math::rows () ((Var mat)))
                 (FunCall stan::math::cols () ((Var mat))) (Var DUMMY_VAR__)))))))
@@ -2827,7 +2910,7 @@
              (FunCall stan::model::index_min_max () ((Literal 3) (Literal 4))))))
           (Expression (Assign (Var current_statement__) (Literal 735)))
           (Return ((Var o))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -2845,19 +2928,22 @@
        false))
      (inline false) (return_type Void) (name f0)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -2868,7 +2954,7 @@
              ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
               (TemplateType T10__) (TemplateType T11__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -2878,11 +2964,11 @@
           (name a10)
           (init (Assignment (FunCall stan::math::to_ref () ((Var a10_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -2895,7 +2981,7 @@
               (FunCall stan::math::stan_print () ((Var pstream__) (Literal "\"hi\""))))
              (Expression (StreamInsertion (Deref (Var pstream__)) ((Literal std::endl))))))
            ()))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -2911,21 +2997,24 @@
          (RequireIs stan::is_vt_not_complex T9__) (RequireIs stan::is_stan_scalar T10__)
          (RequireIs stan::is_stan_scalar T11__)))
        false))
-     (inline false) (return_type Int) (name f1)
+     (inline false) (return_type (Int AoS)) (name f1)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -2936,7 +3025,7 @@
              ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
               (TemplateType T10__) (TemplateType T11__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -2946,11 +3035,11 @@
           (name a10)
           (init (Assignment (FunCall stan::math::to_ref () ((Var a10_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -2958,7 +3047,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 739)))
           (Return ((Var a1))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -2974,21 +3063,24 @@
          (RequireIs stan::is_vt_not_complex T9__) (RequireIs stan::is_stan_scalar T10__)
          (RequireIs stan::is_stan_scalar T11__)))
        false))
-     (inline false) (return_type (StdVector Int)) (name f2)
+     (inline false) (return_type (StdVector (Int AoS) AoS)) (name f2)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -2999,7 +3091,7 @@
              ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
               (TemplateType T10__) (TemplateType T11__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -3009,11 +3101,11 @@
           (name a10)
           (init (Assignment (FunCall stan::math::to_ref () ((Var a10_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3021,7 +3113,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 741)))
           (Return ((Var a2))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -3037,21 +3129,25 @@
          (RequireIs stan::is_vt_not_complex T9__) (RequireIs stan::is_stan_scalar T10__)
          (RequireIs stan::is_stan_scalar T11__)))
        false))
-     (inline false) (return_type (StdVector (StdVector Int))) (name f3)
+     (inline false) (return_type (StdVector (StdVector (Int AoS) AoS) AoS)) 
+     (name f3)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -3062,7 +3158,7 @@
              ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
               (TemplateType T10__) (TemplateType T11__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -3072,11 +3168,11 @@
           (name a10)
           (init (Assignment (FunCall stan::math::to_ref () ((Var a10_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3084,7 +3180,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 743)))
           (Return ((Var a3))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -3110,19 +3206,22 @@
           (TemplateType T10__) (TemplateType T11__))))))
      (name f4)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -3133,7 +3232,7 @@
              ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
               (TemplateType T10__) (TemplateType T11__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -3143,11 +3242,11 @@
           (name a10)
           (init (Assignment (FunCall stan::math::to_ref () ((Var a10_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3155,7 +3254,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 745)))
           (Return ((Var a4))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -3179,22 +3278,26 @@
          (TemplateType stan::base_type_t<T6__>) (TemplateType T7__)
          (TypeTrait stan::promote_args_t
           ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
-           (TemplateType T10__) (TemplateType T11__)))))))
+           (TemplateType T10__) (TemplateType T11__)))))
+       AoS))
      (name f5)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -3205,7 +3308,7 @@
              ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
               (TemplateType T10__) (TemplateType T11__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -3215,11 +3318,11 @@
           (name a10)
           (init (Assignment (FunCall stan::math::to_ref () ((Var a10_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3227,7 +3330,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 747)))
           (Return ((Var a5))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -3252,22 +3355,27 @@
           (TemplateType stan::base_type_t<T6__>) (TemplateType T7__)
           (TypeTrait stan::promote_args_t
            ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
-            (TemplateType T10__) (TemplateType T11__))))))))
+            (TemplateType T10__) (TemplateType T11__)))))
+        AoS)
+       AoS))
      (name f6)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -3278,7 +3386,7 @@
              ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
               (TemplateType T10__) (TemplateType T11__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -3288,11 +3396,11 @@
           (name a10)
           (init (Assignment (FunCall stan::math::to_ref () ((Var a10_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3300,7 +3408,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 749)))
           (Return ((Var a6))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -3328,19 +3436,22 @@
        -1 1 AoS))
      (name f7)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -3351,7 +3462,7 @@
              ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
               (TemplateType T10__) (TemplateType T11__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -3361,11 +3472,11 @@
           (name a10)
           (init (Assignment (FunCall stan::math::to_ref () ((Var a10_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3373,7 +3484,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 751)))
           (Return ((Var a7))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -3399,22 +3510,26 @@
           (TypeTrait stan::promote_args_t
            ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
             (TemplateType T10__) (TemplateType T11__)))))
-        -1 1 AoS)))
+        -1 1 AoS)
+       AoS))
      (name f8)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -3425,7 +3540,7 @@
              ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
               (TemplateType T10__) (TemplateType T11__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -3435,11 +3550,11 @@
           (name a10)
           (init (Assignment (FunCall stan::math::to_ref () ((Var a10_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3447,7 +3562,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 753)))
           (Return ((Var a8))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -3474,22 +3589,27 @@
            (TypeTrait stan::promote_args_t
             ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
              (TemplateType T10__) (TemplateType T11__)))))
-         -1 1 AoS))))
+         -1 1 AoS)
+        AoS)
+       AoS))
      (name f9)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -3500,7 +3620,7 @@
              ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
               (TemplateType T10__) (TemplateType T11__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -3510,11 +3630,11 @@
           (name a10)
           (init (Assignment (FunCall stan::math::to_ref () ((Var a10_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3522,7 +3642,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 755)))
           (Return ((Var a9))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -3550,19 +3670,22 @@
        -1 -1 AoS))
      (name f10)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -3573,7 +3696,7 @@
              ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
               (TemplateType T10__) (TemplateType T11__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -3583,11 +3706,11 @@
           (name a10)
           (init (Assignment (FunCall stan::math::to_ref () ((Var a10_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3595,7 +3718,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 757)))
           (Return ((Var a10))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -3621,22 +3744,26 @@
           (TypeTrait stan::promote_args_t
            ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
             (TemplateType T10__) (TemplateType T11__)))))
-        -1 -1 AoS)))
+        -1 -1 AoS)
+       AoS))
      (name f11)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -3647,7 +3774,7 @@
              ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
               (TemplateType T10__) (TemplateType T11__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -3657,11 +3784,11 @@
           (name a10)
           (init (Assignment (FunCall stan::math::to_ref () ((Var a10_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3669,7 +3796,7 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 759)))
           (Return ((Var a11))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -3696,22 +3823,27 @@
            (TypeTrait stan::promote_args_t
             ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
              (TemplateType T10__) (TemplateType T11__)))))
-         -1 -1 AoS))))
+         -1 -1 AoS)
+        AoS)
+       AoS))
      (name f12)
      (args
-      (((Const (Ref Int)) a1) ((Const (Ref (StdVector Int))) a2)
-       ((Const (Ref (StdVector (StdVector Int)))) a3)
+      (((Const (Ref (Int AoS))) a1) ((Const (Ref (StdVector (Int AoS) AoS))) a2)
+       ((Const (Ref (StdVector (StdVector (Int AoS) AoS) AoS))) a3)
        ((Const (Ref (TemplateType T3__))) a4)
-       ((Const (Ref (StdVector (TemplateType T4__)))) a5)
-       ((Const (Ref (StdVector (StdVector (TemplateType T5__))))) a6)
+       ((Const (Ref (StdVector (TemplateType T4__) AoS))) a5)
+       ((Const (Ref (StdVector (StdVector (TemplateType T5__) AoS) AoS))) a6)
        ((Const (Ref (TemplateType T6__))) a7_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS)))) a8)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS))))) a9)
+       ((Const (Ref (StdVector (Matrix (TemplateType T7__) -1 1 AoS) AoS))) a8)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T8__) -1 1 AoS) AoS) AoS)))
+        a9)
        ((Const (Ref (TemplateType T9__))) a10_arg__)
-       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS)))) a11)
-       ((Const (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS)))))
+       ((Const (Ref (StdVector (Matrix (TemplateType T10__) -1 -1 AoS) AoS))) a11)
+       ((Const
+         (Ref (StdVector (StdVector (Matrix (TemplateType T11__) -1 -1 AoS) AoS) AoS)))
         a12)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -3722,7 +3854,7 @@
              ((TemplateType T8__) (TemplateType stan::base_type_t<T9__>)
               (TemplateType T10__) (TemplateType T11__)))))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -3732,11 +3864,11 @@
           (name a10)
           (init (Assignment (FunCall stan::math::to_ref () ((Var a10_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3744,60 +3876,64 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 761)))
           (Return ((Var a12))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
    (FunDef
     ((templates_init ((()) false)) (inline false) (return_type Void) 
-     (name foo_6) (args (((Pointer (TypeLiteral std::ostream)) pstream__)))
+     (name foo_6) (args (((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
-      (((Using local_scalar_t__ (Double))
+      (((Using local_scalar_t__ ((Double AoS)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
         (Expression (Cast Void (Var DUMMY_VAR__)))
         (TryCatch
          ((VariableDefn
-           ((static false) (constexpr false) (type_ Int) (name a)
+           ((static false) (constexpr false) (type_ (Int AoS)) (name a)
             (init (Assignment (FunCall std::numeric_limits<int>::min () ())))))
           (VariableDefn
-           ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+           ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
             (name b) (init (Assignment (Var DUMMY_VAR__)))))
           (VariableDefn
            ((static false) (constexpr false)
-            (type_ (StdVector (StdVector (TypeLiteral local_scalar_t__)))) 
+            (type_ (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS))
             (name c)
             (init
              (Assignment
-              (Constructor (StdVector (StdVector (TypeLiteral local_scalar_t__)))
+              (Constructor
+               (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
                ((Literal 20)
-                (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                  ((Literal 30) (Var DUMMY_VAR__)))))))))
           (VariableDefn
            ((static false) (constexpr false)
             (type_
-             (StdVector (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))))
+             (StdVector
+              (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS) AoS))
             (name ar_mat)
             (init
              (Assignment
               (Constructor
-               (StdVector (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+               (StdVector
+                (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                AoS)
                ((Literal 60)
                 (Constructor
-                 (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
                  ((Literal 70)
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 40) (Literal 50) (Var DUMMY_VAR__)))))))))))
           (Expression (Assign (Var current_statement__) (Literal 767)))
           (Expression
@@ -3807,25 +3943,25 @@
              (FunCall stan::model::index_uni () ((Literal 1)))
              (FunCall stan::model::index_uni () ((Literal 1)))
              (FunCall stan::model::index_uni () ((Literal 1)))))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
    (FunDef
-    ((templates_init ((()) false)) (inline false) (return_type (Matrix Double -1 -1 AoS))
-     (name matfoo) (args (((Pointer (TypeLiteral std::ostream)) pstream__)))
-     (cv_qualifiers ())
+    ((templates_init ((()) false)) (inline false)
+     (return_type (Matrix (Double AoS) -1 -1 AoS)) (name matfoo)
+     (args (((Pointer (TypeLiteral std::ostream AoS)) pstream__))) (cv_qualifiers ())
      (body
-      (((Using local_scalar_t__ (Double))
+      (((Using local_scalar_t__ ((Double AoS)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3835,11 +3971,11 @@
           (Return
            ((FunCall stan::math::to_matrix ()
              ((InitializerExpr
-               (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+               (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
                ((MethodCall
                  (Parens
                   (StreamInsertion
-                   (Constructor (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
+                   (Constructor (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
                     ((Literal 10)))
                    ((Literal 1) (Literal 2) (Literal 3) (Literal 4) (Literal 5)
                     (Literal 6) (Literal 7) (Literal 8) (Literal 9) (Literal 10))))
@@ -3847,7 +3983,7 @@
                 (MethodCall
                  (Parens
                   (StreamInsertion
-                   (Constructor (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
+                   (Constructor (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
                     ((Literal 10)))
                    ((Literal 1) (Literal 2) (Literal 3) (Literal 4) (Literal 5)
                     (Literal 6) (Literal 7) (Literal 8) (Literal 9) (Literal 10))))
@@ -3855,30 +3991,30 @@
                 (MethodCall
                  (Parens
                   (StreamInsertion
-                   (Constructor (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
+                   (Constructor (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
                     ((Literal 10)))
                    ((Literal 1) (Literal 2) (Literal 3) (Literal 4) (Literal 5)
                     (Literal 6) (Literal 7) (Literal 8) (Literal 9) (Literal 10))))
                  finished () ()))))))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
    (FunDef
-    ((templates_init ((()) false)) (inline false) (return_type (Matrix Double -1 1 AoS))
-     (name vecfoo) (args (((Pointer (TypeLiteral std::ostream)) pstream__)))
-     (cv_qualifiers ())
+    ((templates_init ((()) false)) (inline false)
+     (return_type (Matrix (Double AoS) -1 1 AoS)) (name vecfoo)
+     (args (((Pointer (TypeLiteral std::ostream AoS)) pstream__))) (cv_qualifiers ())
      (body
-      (((Using local_scalar_t__ (Double))
+      (((Using local_scalar_t__ ((Double AoS)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3886,14 +4022,15 @@
         (TryCatch
          ((Expression (Assign (Var current_statement__) (Literal 771)))
           (Return
-           ((FunCall stan::math::promote_scalar ((TypeLiteral local_scalar_t__))
+           ((FunCall stan::math::promote_scalar ((TypeLiteral local_scalar_t__ AoS))
              ((MethodCall
                (Parens
-                (StreamInsertion (Constructor (Matrix Double -1 1 AoS) ((Literal 10)))
+                (StreamInsertion
+                 (Constructor (Matrix (Double AoS) -1 1 AoS) ((Literal 10)))
                  ((Literal 1) (Literal 2) (Literal 3) (Literal 4) (Literal 5) 
                   (Literal 6) (Literal 7) (Literal 8) (Literal 9) (Literal 10))))
                finished () ()))))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -3905,19 +4042,19 @@
      (name vecmufoo)
      (args
       (((Const (Ref (TemplateType T0__))) mu)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__ ((TypeTrait stan::promote_args_t ((TemplateType T0__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3925,12 +4062,12 @@
         (TryCatch
          ((VariableDefn
            ((static false) (constexpr false)
-            (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+            (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
             (name l)
             (init
              (Assignment
-              (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant
-               () ((Literal 10) (Var DUMMY_VAR__)))))))
+              (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+               Constant () ((Literal 10) (Var DUMMY_VAR__)))))))
           (Expression (Assign (Var current_statement__) (Literal 773)))
           (Expression
            (FunCall stan::model::assign ()
@@ -3940,7 +4077,7 @@
              (Literal "\"assigning variable l\""))))
           (Expression (Assign (Var current_statement__) (Literal 774)))
           (Return ((Var l))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -3952,19 +4089,19 @@
      (name vecmubar)
      (args
       (((Const (Ref (TemplateType T0__))) mu)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__ ((TypeTrait stan::promote_args_t ((TemplateType T0__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -3972,12 +4109,12 @@
         (TryCatch
          ((VariableDefn
            ((static false) (constexpr false)
-            (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+            (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
             (name l)
             (init
              (Assignment
-              (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant
-               () ((Literal 10) (Var DUMMY_VAR__)))))))
+              (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+               Constant () ((Literal 10) (Var DUMMY_VAR__)))))))
           (Expression (Assign (Var current_statement__) (Literal 776)))
           (Expression
            (FunCall stan::model::assign ()
@@ -3986,7 +4123,8 @@
               ((Var mu)
                (MethodCall
                 (Parens
-                 (StreamInsertion (Constructor (Matrix Double -1 1 AoS) ((Literal 10)))
+                 (StreamInsertion
+                  (Constructor (Matrix (Double AoS) -1 1 AoS) ((Literal 10)))
                   ((Literal 1) (Literal 2) (Literal 3) (Literal 4) (Literal 5)
                    (Literal 6) (Literal 7) (Literal 8) (Literal 9) (Literal 10))))
                 finished () ())))
@@ -3996,9 +4134,9 @@
            ((FunCall stan::model::rvalue ()
              ((Var l) (Literal "\"l\"")
               (FunCall stan::model::index_multi ()
-               ((InitializerExpr (StdVector Int)
+               ((InitializerExpr (StdVector (Int AoS) AoS)
                  ((Literal 1) (Literal 2) (Literal 3) (Literal 4) (Literal 5))))))))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -4020,9 +4158,9 @@
      (args
       (((Const (Ref (TemplateType T0__))) x_arg__)
        ((Const (Ref (TemplateType T1__))) y_arg__)
-       ((Const (Ref (StdVector (TemplateType T2__)))) dat)
-       ((Const (Ref (StdVector Int))) dat_int)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Const (Ref (StdVector (TemplateType T2__) AoS))) dat)
+       ((Const (Ref (StdVector (Int AoS) AoS))) dat_int)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -4030,7 +4168,7 @@
            ((TemplateType stan::base_type_t<T0__>) (TemplateType stan::base_type_t<T1__>)
             (TemplateType T2__)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -4039,11 +4177,11 @@
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
           (name y) (init (Assignment (FunCall stan::math::to_ref () ((Var y_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -4051,12 +4189,12 @@
         (TryCatch
          ((VariableDefn
            ((static false) (constexpr false)
-            (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+            (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
             (name f_x)
             (init
              (Assignment
-              (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant
-               () ((Literal 2) (Var DUMMY_VAR__)))))))
+              (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+               Constant () ((Literal 2) (Var DUMMY_VAR__)))))))
           (Expression (Assign (Var current_statement__) (Literal 780)))
           (Expression
            (FunCall stan::model::assign ()
@@ -4089,7 +4227,7 @@
              (FunCall stan::model::index_uni () ((Literal 2))))))
           (Expression (Assign (Var current_statement__) (Literal 782)))
           (Return ((Var f_x))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -4109,8 +4247,9 @@
      (args
       (((Const (Ref (TemplateType T0__))) phi_arg__)
        ((Const (Ref (TemplateType T1__))) theta_arg__)
-       ((Const (Ref (StdVector Double))) x_r) ((Const (Ref (StdVector Int))) x_i)
-       ((Pointer (TypeLiteral std::ostream)) pstream__)))
+       ((Const (Ref (StdVector (Double AoS) AoS))) x_r)
+       ((Const (Ref (StdVector (Int AoS) AoS))) x_i)
+       ((Pointer (TypeLiteral std::ostream AoS)) pstream__)))
      (cv_qualifiers ())
      (body
       (((Using local_scalar_t__
@@ -4118,7 +4257,7 @@
            ((TemplateType stan::base_type_t<T0__>)
             (TemplateType stan::base_type_t<T1__>)))))
         (VariableDefn
-         ((static false) (constexpr false) (type_ Int) (name current_statement__)
+         ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
           (init (Assignment (Literal 0)))))
         (VariableDefn
          ((static false) (constexpr false) (type_ (Const (Ref Auto))) 
@@ -4129,11 +4268,11 @@
           (name theta)
           (init (Assignment (FunCall stan::math::to_ref () ((Var theta_arg__)))))))
         (VariableDefn
-         ((static true) (constexpr true) (type_ (TypeLiteral bool)) (name propto__)
-          (init (Assignment (Literal true)))))
+         ((static true) (constexpr true) (type_ (TypeLiteral bool AoS)) 
+          (name propto__) (init (Assignment (Literal true)))))
         (Comment "suppress unused var warning") (Expression (Cast Void (Var propto__)))
         (VariableDefn
-         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+         ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
           (name DUMMY_VAR__)
           (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
         (Comment "suppress unused var warning")
@@ -4141,12 +4280,12 @@
         (TryCatch
          ((VariableDefn
            ((static false) (constexpr false)
-            (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+            (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
             (name lpmf)
             (init
              (Assignment
-              (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant
-               () ((Literal 1) (Var DUMMY_VAR__)))))))
+              (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+               Constant () ((Literal 1) (Var DUMMY_VAR__)))))))
           (Expression (Assign (Var current_statement__) (Literal 785)))
           (Expression
            (FunCall stan::model::assign ()
@@ -4154,339 +4293,380 @@
              (FunCall stan::model::index_uni () ((Literal 1))))))
           (Expression (Assign (Var current_statement__) (Literal 786)))
           (Return ((Var lpmf))))
-         ((Const (Ref (TypeLiteral std::exception))) e)
+         ((Const (Ref (TypeLiteral std::exception AoS))) e)
          ((Expression
            (FunCall stan::lang::rethrow_located ()
             ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
    (Class
     ((class_name mother_model) (final true)
-     (public_base (TypeTrait model_base_crtp ((TypeLiteral mother_model))))
+     (public_base (TypeTrait model_base_crtp ((TypeLiteral mother_model AoS))))
      (private_members
       ((GlobalVariableDefn
-        ((static false) (constexpr false) (type_ Int) (name N) (init Uninitialized)))
-       (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ Int) (name M) (init Uninitialized)))
+        ((static false) (constexpr false) (type_ (Int AoS)) (name N)
+         (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ Int) (name K) (init Uninitialized)))
+        ((static false) (constexpr false) (type_ (Int AoS)) (name M)
+         (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector Int)) (name d_int_1d_ar)
+        ((static false) (constexpr false) (type_ (Int AoS)) (name K)
          (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (StdVector (StdVector Int))))
+        ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
+         (name d_int_1d_ar) (init Uninitialized)))
+       (GlobalVariableDefn
+        ((static false) (constexpr false)
+         (type_ (StdVector (StdVector (StdVector (Int AoS) AoS) AoS) AoS))
          (name d_int_3d_ar) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ Double) (name J) (init Uninitialized)))
+        ((static false) (constexpr false) (type_ (Double AoS)) (name J)
+         (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector Double)) 
+        ((static false) (constexpr false) (type_ (StdVector (Double AoS) AoS))
          (name d_real_1d_ar) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (StdVector Double)))) (name d_real_3d_ar)
-         (init Uninitialized)))
+         (type_ (StdVector (StdVector (StdVector (Double AoS) AoS) AoS) AoS))
+         (name d_real_3d_ar) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
          (name d_vec_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (Matrix Double -1 1 AoS)))
-         (name d_1d_vec) (init Uninitialized)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)) (name d_1d_vec)
+         (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS)))))
+         (type_
+          (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS))
          (name d_3d_vec) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double 1 -1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) 1 -1 AoS))
          (name d_row_vec_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (Matrix Double 1 -1 AoS)))
-         (name d_1d_row_vec) (init Uninitialized)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)) (name d_1d_row_vec)
+         (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (StdVector (Matrix Double 1 -1 AoS)))))
+         (type_
+          (StdVector (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS) AoS))
          (name d_3d_row_vec) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (Matrix Double -1 -1 AoS)))) (name d_ar_mat)
-         (init Uninitialized)))
+         (type_ (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS))
+         (name d_ar_mat) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
          (name d_simplex_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (Matrix Double -1 1 AoS)))
-         (name d_1d_simplex) (init Uninitialized)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)) (name d_1d_simplex)
+         (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS)))))
+         (type_
+          (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS))
          (name d_3d_simplex) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
          (name d_cfcov_54_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
          (name d_cfcov_33_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (Matrix Double -1 -1 AoS)))
-         (name d_cfcov_33_ar) (init Uninitialized)))
-       (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ Int) (name d_int) (init Uninitialized)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)) (name d_cfcov_33_ar)
+         (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector Int)) (name d_int_array)
+        ((static false) (constexpr false) (type_ (Int AoS)) (name d_int)
          (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (StdVector Int)))
-         (name d_int_array_2d) (init Uninitialized)))
+        ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
+         (name d_int_array) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (StdVector (StdVector Int))))
+        ((static false) (constexpr false)
+         (type_ (StdVector (StdVector (Int AoS) AoS) AoS)) (name d_int_array_2d)
+         (init Uninitialized)))
+       (GlobalVariableDefn
+        ((static false) (constexpr false)
+         (type_ (StdVector (StdVector (StdVector (Int AoS) AoS) AoS) AoS))
          (name d_int_array_3d) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ Double) (name d_real)
+        ((static false) (constexpr false) (type_ (Double AoS)) (name d_real)
          (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector Double)) 
+        ((static false) (constexpr false) (type_ (StdVector (Double AoS) AoS))
          (name d_real_array) (init Uninitialized)))
-       (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (StdVector Double)))
-         (name d_real_array_2d) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (StdVector Double)))) (name d_real_array_3d)
+         (type_ (StdVector (StdVector (Double AoS) AoS) AoS)) (name d_real_array_2d)
          (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+        ((static false) (constexpr false)
+         (type_ (StdVector (StdVector (StdVector (Double AoS) AoS) AoS) AoS))
+         (name d_real_array_3d) (init Uninitialized)))
+       (GlobalVariableDefn
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
          (name d_matrix_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (Matrix Double -1 -1 AoS)))
-         (name d_matrix_array) (init Uninitialized)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)) (name d_matrix_array)
+         (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (Matrix Double -1 -1 AoS))))
+         (type_ (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS))
          (name d_matrix_array_2d) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (StdVector (Matrix Double -1 -1 AoS)))))
+         (type_
+          (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS) AoS))
          (name d_matrix_array_3d) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
          (name d_vector_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (Matrix Double -1 1 AoS)))
-         (name d_vector_array) (init Uninitialized)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)) (name d_vector_array)
+         (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (Matrix Double -1 1 AoS))))
+         (type_ (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS))
          (name d_vector_array_2d) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS)))))
+         (type_
+          (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS))
          (name d_vector_array_3d) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double 1 -1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) 1 -1 AoS))
          (name d_row_vector_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (Matrix Double 1 -1 AoS)))
-         (name d_row_vector_array) (init Uninitialized)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)) (name d_row_vector_array)
+         (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (Matrix Double 1 -1 AoS))))
+         (type_ (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS))
          (name d_row_vector_array_2d) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (StdVector (Matrix Double 1 -1 AoS)))))
+         (type_
+          (StdVector (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS) AoS))
          (name d_row_vector_array_3d) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ Int) (name td_int) (init Uninitialized)))
-       (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector Int)) (name td_1d)
+        ((static false) (constexpr false) (type_ (Int AoS)) (name td_int)
          (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector Int)) (name td_1dk)
-         (init Uninitialized)))
+        ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS)) 
+         (name td_1d) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ Int) (name td_a) (init Uninitialized)))
+        ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS)) 
+         (name td_1dk) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ Double) (name td_b)
+        ((static false) (constexpr false) (type_ (Int AoS)) (name td_a)
          (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ Double) (name td_c)
+        ((static false) (constexpr false) (type_ (Double AoS)) (name td_b)
          (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (Matrix Double -1 -1 AoS)))) (name td_ar_mat)
+        ((static false) (constexpr false) (type_ (Double AoS)) (name td_c)
          (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+        ((static false) (constexpr false)
+         (type_ (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS))
+         (name td_ar_mat) (init Uninitialized)))
+       (GlobalVariableDefn
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
          (name td_simplex_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (Matrix Double -1 1 AoS)))
-         (name td_1d_simplex) (init Uninitialized)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)) (name td_1d_simplex)
+         (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS)))))
+         (type_
+          (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS))
          (name td_3d_simplex) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
          (name td_cfcov_54_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
          (name td_cfcov_33_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
          (name x_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
          (name y_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector Double)) 
+        ((static false) (constexpr false) (type_ (StdVector (Double AoS) AoS)) 
          (name dat) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector Int)) (name dat_int)
-         (init Uninitialized)))
+        ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
+         (name dat_int) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (StdVector Double)))
-         (name x_r) (init Uninitialized)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (StdVector (Double AoS) AoS) AoS)) (name x_r)
+         (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (StdVector Int))) 
-         (name x_i) (init Uninitialized)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (StdVector (Int AoS) AoS) AoS)) (name x_i)
+         (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (StdVector Int)))
-         (name arr_mul_ind) (init Uninitialized)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (StdVector (Int AoS) AoS) AoS)) (name arr_mul_ind)
+         (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector Double)) 
+        ((static false) (constexpr false) (type_ (StdVector (Double AoS) AoS))
          (name x_mul_ind) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ Double) (name transformed_data_real)
-         (init Uninitialized)))
+        ((static false) (constexpr false) (type_ (Double AoS))
+         (name transformed_data_real) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector Double))
+        ((static false) (constexpr false) (type_ (StdVector (Double AoS) AoS))
          (name transformed_data_real_array) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (StdVector Double)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (StdVector (Double AoS) AoS) AoS))
          (name transformed_data_real_array_2d) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (StdVector Double))))
+         (type_ (StdVector (StdVector (StdVector (Double AoS) AoS) AoS) AoS))
          (name transformed_data_real_array_3d) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
          (name transformed_data_matrix_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (Matrix Double -1 -1 AoS)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS))
          (name transformed_data_matrix_array) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (Matrix Double -1 -1 AoS))))
+         (type_ (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS))
          (name transformed_data_matrix_array_2d) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (StdVector (Matrix Double -1 -1 AoS)))))
+         (type_
+          (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS) AoS))
          (name transformed_data_matrix_array_3d) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
          (name transformed_data_vector_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (Matrix Double -1 1 AoS)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (Matrix (Double AoS) -1 1 AoS) AoS))
          (name transformed_data_vector_array) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (Matrix Double -1 1 AoS))))
+         (type_ (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS))
          (name transformed_data_vector_array_2d) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS)))))
+         (type_
+          (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS))
          (name transformed_data_vector_array_3d) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (Matrix Double 1 -1 AoS))
+        ((static false) (constexpr false) (type_ (Matrix (Double AoS) 1 -1 AoS))
          (name transformed_data_row_vector_data__) (init Uninitialized)))
        (GlobalVariableDefn
-        ((static false) (constexpr false) (type_ (StdVector (Matrix Double 1 -1 AoS)))
+        ((static false) (constexpr false)
+         (type_ (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS))
          (name transformed_data_row_vector_array) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (Matrix Double 1 -1 AoS))))
+         (type_ (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS))
          (name transformed_data_row_vector_array_2d) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (StdVector (StdVector (StdVector (Matrix Double 1 -1 AoS)))))
+         (type_
+          (StdVector (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS) AoS))
          (name transformed_data_row_vector_array_3d) (init Uninitialized)))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))) (name d_vec)
-         (init (InitializerList ((Literal nullptr) (Literal 0))))))
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS)))) 
+         (name d_vec) (init (InitializerList ((Literal nullptr) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double 1 -1 AoS)))) (name d_row_vec)
-         (init (InitializerList ((Literal nullptr) (Literal 0))))))
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) 1 -1 AoS)))) 
+         (name d_row_vec) (init (InitializerList ((Literal nullptr) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))) (name d_simplex)
-         (init (InitializerList ((Literal nullptr) (Literal 0))))))
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS)))) 
+         (name d_simplex) (init (InitializerList ((Literal nullptr) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double -1 -1 AoS)))) (name d_cfcov_54)
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 -1 AoS))))
+         (name d_cfcov_54)
          (init (InitializerList ((Literal nullptr) (Literal 0) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double -1 -1 AoS)))) (name d_cfcov_33)
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 -1 AoS))))
+         (name d_cfcov_33)
          (init (InitializerList ((Literal nullptr) (Literal 0) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double -1 -1 AoS)))) (name d_matrix)
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 -1 AoS)))) 
+         (name d_matrix)
          (init (InitializerList ((Literal nullptr) (Literal 0) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))) (name d_vector)
-         (init (InitializerList ((Literal nullptr) (Literal 0))))))
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS)))) 
+         (name d_vector) (init (InitializerList ((Literal nullptr) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double 1 -1 AoS)))) (name d_row_vector)
-         (init (InitializerList ((Literal nullptr) (Literal 0))))))
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) 1 -1 AoS))))
+         (name d_row_vector) (init (InitializerList ((Literal nullptr) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))) (name td_simplex)
-         (init (InitializerList ((Literal nullptr) (Literal 0))))))
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS))))
+         (name td_simplex) (init (InitializerList ((Literal nullptr) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double -1 -1 AoS)))) (name td_cfcov_54)
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 -1 AoS))))
+         (name td_cfcov_54)
          (init (InitializerList ((Literal nullptr) (Literal 0) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double -1 -1 AoS)))) (name td_cfcov_33)
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 -1 AoS))))
+         (name td_cfcov_33)
          (init (InitializerList ((Literal nullptr) (Literal 0) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))) (name x)
-         (init (InitializerList ((Literal nullptr) (Literal 0))))))
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS)))) 
+         (name x) (init (InitializerList ((Literal nullptr) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))) (name y)
-         (init (InitializerList ((Literal nullptr) (Literal 0))))))
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS)))) 
+         (name y) (init (InitializerList ((Literal nullptr) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double -1 -1 AoS))))
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 -1 AoS))))
          (name transformed_data_matrix)
          (init (InitializerList ((Literal nullptr) (Literal 0) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS))))
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS))))
          (name transformed_data_vector)
          (init (InitializerList ((Literal nullptr) (Literal 0))))))
        (GlobalVariableDefn
         ((static false) (constexpr false)
-         (type_ (TypeTrait Eigen::Map ((Matrix Double 1 -1 AoS))))
+         (type_ (TypeTrait Eigen::Map ((Matrix (Double AoS) 1 -1 AoS))))
          (name transformed_data_row_vector)
          (init (InitializerList ((Literal nullptr) (Literal 0))))))))
      (public_members
       ((FunDef
         ((templates_init ((()) false)) (inline true)
-         (return_type (TypeLiteral std::string)) (name model_name) (args ())
-         (cv_qualifiers (Const Final))
+         (return_type (TypeLiteral std::string AoS)) (name model_name) 
+         (args ()) (cv_qualifiers (Const Final))
          (body (((Return ((Literal "\"mother_model\""))))))))
        (FunDef
         ((templates_init ((()) false)) (inline true)
-         (return_type (StdVector (TypeLiteral std::string))) (name model_compile_info)
-         (args ()) (cv_qualifiers (Const NoExcept))
+         (return_type (StdVector (TypeLiteral std::string AoS) AoS))
+         (name model_compile_info) (args ()) (cv_qualifiers (Const NoExcept))
          (body
           (((Return
-             ((InitializerExpr (StdVector (TypeLiteral std::string))
+             ((InitializerExpr (StdVector (TypeLiteral std::string AoS) AoS)
                ((Literal "\"stanc_version = %%NAME%%3 %%VERSION%%\"")
                 (Literal "\"stancflags = --debug-lir\""))))))))))
        (GlobalComment "Base log prob")
@@ -4502,196 +4682,220 @@
          (name log_prob_impl)
          (args
           (((Ref (TemplateType VecR)) params_r__) ((Ref (TemplateType VecI)) params_i__)
-           ((Pointer (TypeLiteral std::ostream)) "pstream__ = nullptr")))
+           ((Pointer (TypeLiteral std::ostream AoS)) "pstream__ = nullptr")))
          (cv_qualifiers (Const))
          (body
           (((Using T__ ((TypeTrait stan::scalar_type_t ((TemplateType VecR)))))
-            (Using local_scalar_t__ ((TypeLiteral T__)))
+            (Using local_scalar_t__ ((TypeLiteral T__ AoS)))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (TypeLiteral T__)) 
+             ((static false) (constexpr false) (type_ (TypeLiteral T__ AoS)) 
               (name lp__) (init (Construction ((Literal 0.0))))))
             (VariableDefn
              ((static false) (constexpr false)
-              (type_ (TypeTrait stan::math::accumulator ((TypeLiteral T__))))
+              (type_ (TypeTrait stan::math::accumulator ((TypeLiteral T__ AoS))))
               (name lp_accum__) (init Uninitialized)))
             (VariableDefn
              ((static false) (constexpr false)
-              (type_ (TypeTrait stan::io::deserializer ((TypeLiteral local_scalar_t__))))
+              (type_
+               (TypeTrait stan::io::deserializer ((TypeLiteral local_scalar_t__ AoS))))
               (name in__) (init (Construction ((Var params_r__) (Var params_i__))))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ Int) (name current_statement__)
-              (init (Assignment (Literal 0)))))
+             ((static false) (constexpr false) (type_ (Int AoS))
+              (name current_statement__) (init (Assignment (Literal 0)))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+             ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
               (name DUMMY_VAR__)
               (init
                (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
             (Comment "suppress unused var warning")
             (Expression (Cast Void (Var DUMMY_VAR__)))
             (VariableDefn
-             ((static true) (constexpr true) (type_ (Const (Pointer (TypeLiteral char))))
-              (name function__)
+             ((static true) (constexpr true)
+              (type_ (Const (Pointer (TypeLiteral char AoS)))) (name function__)
               (init (Assignment (Literal "\"mother_model_namespace::log_prob\"")))))
             (Comment "suppress unused var warning")
             (Expression (Cast Void (Var function__)))
             (TryCatch
              ((VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name p_real) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name p_real)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 1)))
               (Expression
                (Assign (Var p_real)
-                (MethodCall (Var in__) "template read" ((TypeLiteral local_scalar_t__))
-                 ())))
+                (MethodCall (Var in__) "template read"
+                 ((TypeLiteral local_scalar_t__ AoS)) ())))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name p_upper) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name p_upper)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 2)))
               (Expression
                (Assign (Var p_upper)
                 (MethodCall (Var in__) "template read_constrain_lb"
-                 ((TypeLiteral local_scalar_t__) (TemplateType jacobian__))
+                 ((TypeLiteral local_scalar_t__ AoS) (TemplateType jacobian__))
                  ((Var p_real) (Var lp__)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name p_lower) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name p_lower)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 3)))
               (Expression
                (Assign (Var p_lower)
                 (MethodCall (Var in__) "template read_constrain_ub"
-                 ((TypeLiteral local_scalar_t__) (TemplateType jacobian__))
+                 ((TypeLiteral local_scalar_t__ AoS) (TemplateType jacobian__))
                  ((Var p_upper) (Var lp__)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                 (name offset_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Literal 5) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 4)))
               (Expression
                (Assign (Var offset_multiplier)
                 (MethodCall (Var in__) "template read_constrain_offset_multiplier"
-                 ((StdVector (TypeLiteral local_scalar_t__)) (TemplateType jacobian__))
+                 ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
+                  (TemplateType jacobian__))
                  ((Literal 1) (Literal 2) (Var lp__) (Literal 5)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                 (name no_offset_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Literal 5) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 5)))
               (Expression
                (Assign (Var no_offset_multiplier)
                 (MethodCall (Var in__) "template read_constrain_offset_multiplier"
-                 ((StdVector (TypeLiteral local_scalar_t__)) (TemplateType jacobian__))
+                 ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
+                  (TemplateType jacobian__))
                  ((Literal 0) (Literal 2) (Var lp__) (Literal 5)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                 (name offset_no_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Literal 5) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 6)))
               (Expression
                (Assign (Var offset_no_multiplier)
                 (MethodCall (Var in__) "template read_constrain_offset_multiplier"
-                 ((StdVector (TypeLiteral local_scalar_t__)) (TemplateType jacobian__))
+                 ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
+                  (TemplateType jacobian__))
                  ((Literal 3) (Literal 1) (Var lp__) (Literal 5)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__))) (name p_real_1d_ar)
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+                (name p_real_1d_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Var N) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 7)))
               (Expression
                (Assign (Var p_real_1d_ar)
                 (MethodCall (Var in__) "template read_constrain_lb"
-                 ((StdVector (TypeLiteral local_scalar_t__)) (TemplateType jacobian__))
+                 ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
+                  (TemplateType jacobian__))
                  ((Literal 0) (Var lp__) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
-                 (StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__)))))
+                 (StdVector
+                  (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS) AoS))
                 (name p_real_3d_ar)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__))))
+                   (StdVector
+                    (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
+                    AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (TypeLiteral local_scalar_t__)))
+                    (Constructor
+                     (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                      (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                        ((Var K) (Var DUMMY_VAR__)))))))))))
               (Expression (Assign (Var current_statement__) (Literal 8)))
               (Expression
                (Assign (Var p_real_3d_ar)
                 (MethodCall (Var in__) "template read_constrain_lb"
-                 ((StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__))))
+                 ((StdVector
+                   (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
+                   AoS)
                   (TemplateType jacobian__))
                  ((Literal 0) (Var lp__) (Var N) (Var M) (Var K)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                 (name p_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 9)))
               (Expression
                (Assign (Var p_vec)
                 (MethodCall (Var in__) "template read_constrain_lb"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                   (TemplateType jacobian__))
                  ((Literal 0) (Var lp__) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                 (name p_1d_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (Expression (Assign (Var current_statement__) (Literal 10)))
               (Expression
                (Assign (Var p_1d_vec)
                 (MethodCall (Var in__) "template read"
-                 ((StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                 ((StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                  ((Var N) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name p_3d_vec)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 11)))
               (Expression
@@ -4699,61 +4903,73 @@
                 (MethodCall (Var in__) "template read"
                  ((StdVector
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                    AoS)
+                   AoS))
                  ((Var N) (Var M) (Var K) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS))
                 (name p_row_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 12)))
               (Expression
                (Assign (Var p_row_vec)
                 (MethodCall (Var in__) "template read"
-                 ((Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)) ((Var N)))))
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)) 
+                 ((Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS))
                 (name p_1d_row_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (Expression (Assign (Var current_statement__) (Literal 13)))
               (Expression
                (Assign (Var p_1d_row_vec)
                 (MethodCall (Var in__) "template read"
-                 ((StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                 ((StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS))
                  ((Var N) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name p_3d_row_vec)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 14)))
               (Expression
@@ -4761,79 +4977,88 @@
                 (MethodCall (Var in__) "template read"
                  ((StdVector
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                    AoS)
+                   AoS))
                  ((Var N) (Var M) (Var K) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name p_mat)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 5) (Literal 4) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 15)))
               (Expression
                (Assign (Var p_mat)
                 (MethodCall (Var in__) "template read"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                  ((Literal 5) (Literal 4)))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
-                  (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))))
+                  (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                  AoS))
                 (name p_ar_mat)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                    AoS)
                    ((Literal 4)
                     (Constructor
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
+                      AoS)
                      ((Literal 5)
-                      (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
-                       Constant () ((Literal 2) (Literal 3) (Var DUMMY_VAR__)))))))))))
+                      (StaticMethodCall
+                       (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) Constant ()
+                       ((Literal 2) (Literal 3) (Var DUMMY_VAR__)))))))))))
               (Expression (Assign (Var current_statement__) (Literal 16)))
               (Expression
                (Assign (Var p_ar_mat)
                 (MethodCall (Var in__) "template read_constrain_lub"
                  ((StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                   AoS)
                   (TemplateType jacobian__))
                  ((Literal 0) (Literal 1) (Var lp__) (Literal 4) (Literal 5) 
                   (Literal 2) (Literal 3)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS))
                 (name p_simplex)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 17)))
               (Expression
                (Assign (Var p_simplex)
                 (MethodCall (Var in__) "template read_constrain_simplex"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                 (name p_1d_simplex)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (Expression (Assign (Var current_statement__) (Literal 18)))
               (Expression
                (Assign (Var p_1d_simplex)
                 (MethodCall (Var in__) "template read_constrain_simplex"
-                 ((StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                 ((StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Var N) (Var N)))))
               (VariableDefn
@@ -4841,24 +5066,31 @@
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name p_3d_simplex)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 19)))
               (Expression
@@ -4866,296 +5098,341 @@
                 (MethodCall (Var in__) "template read_constrain_simplex"
                  ((StdVector
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                    AoS)
+                   AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Var N) (Var M) (Var K) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name p_cfcov_54)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 5) (Literal 4) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 20)))
               (Expression
                (Assign (Var p_cfcov_54)
                 (MethodCall (Var in__) "template read_constrain_cholesky_factor_cov"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Literal 5) (Literal 4)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name p_cfcov_33)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 21)))
               (Expression
                (Assign (Var p_cfcov_33)
                 (MethodCall (Var in__) "template read_constrain_cholesky_factor_cov"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Literal 3) (Literal 3)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS))
                 (name p_cfcov_33_ar)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
                    ((Var K)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
-                     Constant () ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) Constant ()
+                     ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))))
               (Expression (Assign (Var current_statement__) (Literal 22)))
               (Expression
                (Assign (Var p_cfcov_33_ar)
                 (MethodCall (Var in__) "template read_constrain_cholesky_factor_cov"
-                 ((StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                 ((StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Var K) (Literal 3) (Literal 3)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                 (name x_p)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Literal 2) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 23)))
               (Expression
                (Assign (Var x_p)
                 (MethodCall (Var in__) "template read"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) ((Literal 2)))))
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
+                 ((Literal 2)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                 (name y_p)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Literal 2) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 24)))
               (Expression
                (Assign (Var y_p)
                 (MethodCall (Var in__) "template read"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) ((Literal 2)))))
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
+                 ((Literal 2)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__))) (name tp_real_1d_ar)
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+                (name tp_real_1d_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Var N) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
-                 (StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__)))))
+                 (StdVector
+                  (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS) AoS))
                 (name tp_real_3d_ar)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__))))
+                   (StdVector
+                    (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
+                    AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (TypeLiteral local_scalar_t__)))
+                    (Constructor
+                     (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                      (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                        ((Var K) (Var DUMMY_VAR__)))))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS))
                 (name tp_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                 (name tp_1d_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name tp_3d_vec)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS))
                 (name tp_row_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS))
                 (name tp_1d_row_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name tp_3d_row_vec)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name tp_mat)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 5) (Literal 4) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
-                  (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))))
+                  (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                  AoS))
                 (name tp_ar_mat)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                    AoS)
                    ((Literal 4)
                     (Constructor
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
+                      AoS)
                      ((Literal 5)
-                      (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
-                       Constant () ((Literal 2) (Literal 3) (Var DUMMY_VAR__)))))))))))
+                      (StaticMethodCall
+                       (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) Constant ()
+                       ((Literal 2) (Literal 3) (Var DUMMY_VAR__)))))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS))
                 (name tp_simplex)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                 (name tp_1d_simplex)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name tp_3d_simplex)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name tp_cfcov_54)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 5) (Literal 4) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name tp_cfcov_33)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS))
                 (name tp_cfcov_33_ar)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
                    ((Var K)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
-                     Constant () ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) Constant ()
+                     ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS))
                 (name theta_p)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Literal 2) (Var DUMMY_VAR__)))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name tp_real) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name tp_real)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 70)))
               (Expression
                (FunCall stan::model::assign ()
@@ -5220,25 +5497,25 @@
                  (Literal "\"assigning variable tp_vec\""))))
               (Expression (Assign (Var current_statement__) (Literal 90)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name i)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name i)
                 (init (Assignment (Literal 1))))
                (BinOp (Var i) LEq (Literal 2)) (Increment (Var i))
                (Block
                 ((Expression (Assign (Var current_statement__) (Literal 88)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name j)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name j) (init (Assignment (Literal 1))))
                   (BinOp (Var j) LEq (Literal 3)) (Increment (Var j))
                   (Block
                    ((Expression (Assign (Var current_statement__) (Literal 86)))
                     (For
-                     ((static false) (constexpr false) (type_ Int) (name m)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name m) (init (Assignment (Literal 1))))
                      (BinOp (Var m) LEq (Literal 4)) (Increment (Var m))
                      (Block
                       ((Expression (Assign (Var current_statement__) (Literal 84)))
                        (For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name n) (init (Assignment (Literal 1))))
                         (BinOp (Var n) LEq (Literal 5)) (Increment (Var n))
                         (Block
@@ -5253,7 +5530,7 @@
                              (FunCall stan::model::index_uni () ((Var j))))))))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 92)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name i)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name i)
                 (init (Assignment (Literal 1))))
                (BinOp (Var i) LEq (Var N)) (Increment (Var i))
                (Block
@@ -5402,32 +5679,37 @@
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                  (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                   (name tmp)
                   (init
                    (Assignment
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Literal 0) (Var DUMMY_VAR__)))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Literal 0) (Var DUMMY_VAR__)))))))
                 (VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                  (type_
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                   (name tmp2)
                   (init
                    (Assignment
                     (Constructor
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                      ((Literal 0)
-                      (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                       Constant () ((Literal 0) (Var DUMMY_VAR__)))))))))
+                      (StaticMethodCall
+                       (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                       ((Literal 0) (Var DUMMY_VAR__)))))))))
                 (VariableDefn
-                 ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                  (name r1) (init (Assignment (Var DUMMY_VAR__)))))
+                 ((static false) (constexpr false)
+                  (type_ (TypeLiteral local_scalar_t__ AoS)) (name r1)
+                  (init (Assignment (Var DUMMY_VAR__)))))
                 (Expression (Assign (Var current_statement__) (Literal 156)))
                 (Expression
                  (Assign (Var r1) (FunCall foo_bar1 () ((Var p_real) (Var pstream__)))))
                 (VariableDefn
-                 ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                  (name r2) (init (Assignment (Var DUMMY_VAR__)))))
+                 ((static false) (constexpr false)
+                  (type_ (TypeLiteral local_scalar_t__ AoS)) (name r2)
+                  (init (Assignment (Var DUMMY_VAR__)))))
                 (Expression (Assign (Var current_statement__) (Literal 157)))
                 (Expression
                  (Assign (Var r2) (FunCall foo_bar1 () ((Var J) (Var pstream__)))))
@@ -5459,8 +5741,8 @@
                      (Literal 0) (Literal 1))))))
                 (Expression (Assign (Var current_statement__) (Literal 175)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name n)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name n) (init (Assignment (Literal 1))))
                  (BinOp (Var n) LEq (Var N)) (Increment (Var n))
                  (Block
                   ((Expression (Assign (Var current_statement__) (Literal 163)))
@@ -5492,13 +5774,13 @@
                         (Literal 0) (Literal 1))))))
                    (Expression (Assign (Var current_statement__) (Literal 173)))
                    (For
-                    ((static false) (constexpr false) (type_ Int) (name m)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name m) (init (Assignment (Literal 1))))
                     (BinOp (Var m) LEq (Var M)) (Increment (Var m))
                     (Block
                      ((Expression (Assign (Var current_statement__) (Literal 171)))
                       (For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name k) (init (Assignment (Literal 1))))
                        (BinOp (Var k) LEq (Var K)) (Increment (Var k))
                        (Block
@@ -5567,14 +5849,14 @@
                               (Literal 1)))))))))))))))
                 (Expression (Assign (Var current_statement__) (Literal 180)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name i)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name i) (init (Assignment (Literal 1))))
                  (BinOp (Var i) LEq (Literal 4)) (Increment (Var i))
                  (Block
                   ((Expression (Assign (Var current_statement__) (Literal 178)))
                    (For
-                    ((static false) (constexpr false) (type_ Int) (name j)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name j) (init (Assignment (Literal 1))))
                     (BinOp (Var j) LEq (Literal 5)) (Increment (Var j))
                     (Block
                      ((Expression (Assign (Var current_statement__) (Literal 176)))
@@ -5589,8 +5871,8 @@
                            (Literal 0) (Literal 1))))))))))))
                 (Expression (Assign (Var current_statement__) (Literal 183)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name k)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name k) (init (Assignment (Literal 1))))
                  (BinOp (Var k) LEq (Var K)) (Increment (Var k))
                  (Block
                   ((Expression (Assign (Var current_statement__) (Literal 181)))
@@ -5637,7 +5919,7 @@
                  (MethodCall (Var lp_accum__) add ()
                   ((FunCall "stan::math::map_rect<2, binomialf_functor__>" ()
                     ((Var tmp) (Var tmp2) (Var x_r) (Var x_i) (Var pstream__)))))))))
-             ((Const (Ref (TypeLiteral std::exception))) e)
+             ((Const (Ref (TypeLiteral std::exception AoS))) e)
              ((Expression
                (FunCall stan::lang::rethrow_located ()
                 ((Var e) (Index (Var locations_array__) (Var current_statement__)))))))
@@ -5656,196 +5938,220 @@
          (name log_prob_impl)
          (args
           (((Ref (TemplateType VecR)) params_r__) ((Ref (TemplateType VecI)) params_i__)
-           ((Pointer (TypeLiteral std::ostream)) "pstream__ = nullptr")))
+           ((Pointer (TypeLiteral std::ostream AoS)) "pstream__ = nullptr")))
          (cv_qualifiers (Const))
          (body
           (((Using T__ ((TypeTrait stan::scalar_type_t ((TemplateType VecR)))))
-            (Using local_scalar_t__ ((TypeLiteral T__)))
+            (Using local_scalar_t__ ((TypeLiteral T__ AoS)))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (TypeLiteral T__)) 
+             ((static false) (constexpr false) (type_ (TypeLiteral T__ AoS)) 
               (name lp__) (init (Construction ((Literal 0.0))))))
             (VariableDefn
              ((static false) (constexpr false)
-              (type_ (TypeTrait stan::math::accumulator ((TypeLiteral T__))))
+              (type_ (TypeTrait stan::math::accumulator ((TypeLiteral T__ AoS))))
               (name lp_accum__) (init Uninitialized)))
             (VariableDefn
              ((static false) (constexpr false)
-              (type_ (TypeTrait stan::io::deserializer ((TypeLiteral local_scalar_t__))))
+              (type_
+               (TypeTrait stan::io::deserializer ((TypeLiteral local_scalar_t__ AoS))))
               (name in__) (init (Construction ((Var params_r__) (Var params_i__))))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ Int) (name current_statement__)
-              (init (Assignment (Literal 0)))))
+             ((static false) (constexpr false) (type_ (Int AoS))
+              (name current_statement__) (init (Assignment (Literal 0)))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+             ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
               (name DUMMY_VAR__)
               (init
                (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
             (Comment "suppress unused var warning")
             (Expression (Cast Void (Var DUMMY_VAR__)))
             (VariableDefn
-             ((static true) (constexpr true) (type_ (Const (Pointer (TypeLiteral char))))
-              (name function__)
+             ((static true) (constexpr true)
+              (type_ (Const (Pointer (TypeLiteral char AoS)))) (name function__)
               (init (Assignment (Literal "\"mother_model_namespace::log_prob\"")))))
             (Comment "suppress unused var warning")
             (Expression (Cast Void (Var function__)))
             (TryCatch
              ((VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name p_real) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name p_real)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 1)))
               (Expression
                (Assign (Var p_real)
-                (MethodCall (Var in__) "template read" ((TypeLiteral local_scalar_t__))
-                 ())))
+                (MethodCall (Var in__) "template read"
+                 ((TypeLiteral local_scalar_t__ AoS)) ())))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name p_upper) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name p_upper)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 2)))
               (Expression
                (Assign (Var p_upper)
                 (MethodCall (Var in__) "template read_constrain_lb"
-                 ((TypeLiteral local_scalar_t__) (TemplateType jacobian__))
+                 ((TypeLiteral local_scalar_t__ AoS) (TemplateType jacobian__))
                  ((Var p_real) (Var lp__)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name p_lower) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name p_lower)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 3)))
               (Expression
                (Assign (Var p_lower)
                 (MethodCall (Var in__) "template read_constrain_ub"
-                 ((TypeLiteral local_scalar_t__) (TemplateType jacobian__))
+                 ((TypeLiteral local_scalar_t__ AoS) (TemplateType jacobian__))
                  ((Var p_upper) (Var lp__)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                 (name offset_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Literal 5) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 4)))
               (Expression
                (Assign (Var offset_multiplier)
                 (MethodCall (Var in__) "template read_constrain_offset_multiplier"
-                 ((StdVector (TypeLiteral local_scalar_t__)) (TemplateType jacobian__))
+                 ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
+                  (TemplateType jacobian__))
                  ((Literal 1) (Literal 2) (Var lp__) (Literal 5)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                 (name no_offset_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Literal 5) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 5)))
               (Expression
                (Assign (Var no_offset_multiplier)
                 (MethodCall (Var in__) "template read_constrain_offset_multiplier"
-                 ((StdVector (TypeLiteral local_scalar_t__)) (TemplateType jacobian__))
+                 ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
+                  (TemplateType jacobian__))
                  ((Literal 0) (Literal 2) (Var lp__) (Literal 5)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                 (name offset_no_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Literal 5) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 6)))
               (Expression
                (Assign (Var offset_no_multiplier)
                 (MethodCall (Var in__) "template read_constrain_offset_multiplier"
-                 ((StdVector (TypeLiteral local_scalar_t__)) (TemplateType jacobian__))
+                 ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
+                  (TemplateType jacobian__))
                  ((Literal 3) (Literal 1) (Var lp__) (Literal 5)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__))) (name p_real_1d_ar)
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+                (name p_real_1d_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Var N) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 7)))
               (Expression
                (Assign (Var p_real_1d_ar)
                 (MethodCall (Var in__) "template read_constrain_lb"
-                 ((StdVector (TypeLiteral local_scalar_t__)) (TemplateType jacobian__))
+                 ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
+                  (TemplateType jacobian__))
                  ((Literal 0) (Var lp__) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
-                 (StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__)))))
+                 (StdVector
+                  (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS) AoS))
                 (name p_real_3d_ar)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__))))
+                   (StdVector
+                    (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
+                    AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (TypeLiteral local_scalar_t__)))
+                    (Constructor
+                     (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                      (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                        ((Var K) (Var DUMMY_VAR__)))))))))))
               (Expression (Assign (Var current_statement__) (Literal 8)))
               (Expression
                (Assign (Var p_real_3d_ar)
                 (MethodCall (Var in__) "template read_constrain_lb"
-                 ((StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__))))
+                 ((StdVector
+                   (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
+                   AoS)
                   (TemplateType jacobian__))
                  ((Literal 0) (Var lp__) (Var N) (Var M) (Var K)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                 (name p_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 9)))
               (Expression
                (Assign (Var p_vec)
                 (MethodCall (Var in__) "template read_constrain_lb"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                   (TemplateType jacobian__))
                  ((Literal 0) (Var lp__) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                 (name p_1d_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (Expression (Assign (Var current_statement__) (Literal 10)))
               (Expression
                (Assign (Var p_1d_vec)
                 (MethodCall (Var in__) "template read"
-                 ((StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                 ((StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                  ((Var N) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name p_3d_vec)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 11)))
               (Expression
@@ -5853,61 +6159,73 @@
                 (MethodCall (Var in__) "template read"
                  ((StdVector
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                    AoS)
+                   AoS))
                  ((Var N) (Var M) (Var K) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS))
                 (name p_row_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 12)))
               (Expression
                (Assign (Var p_row_vec)
                 (MethodCall (Var in__) "template read"
-                 ((Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)) ((Var N)))))
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)) 
+                 ((Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS))
                 (name p_1d_row_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (Expression (Assign (Var current_statement__) (Literal 13)))
               (Expression
                (Assign (Var p_1d_row_vec)
                 (MethodCall (Var in__) "template read"
-                 ((StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                 ((StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS))
                  ((Var N) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name p_3d_row_vec)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 14)))
               (Expression
@@ -5915,79 +6233,88 @@
                 (MethodCall (Var in__) "template read"
                  ((StdVector
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                    AoS)
+                   AoS))
                  ((Var N) (Var M) (Var K) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name p_mat)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 5) (Literal 4) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 15)))
               (Expression
                (Assign (Var p_mat)
                 (MethodCall (Var in__) "template read"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                  ((Literal 5) (Literal 4)))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
-                  (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))))
+                  (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                  AoS))
                 (name p_ar_mat)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                    AoS)
                    ((Literal 4)
                     (Constructor
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
+                      AoS)
                      ((Literal 5)
-                      (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
-                       Constant () ((Literal 2) (Literal 3) (Var DUMMY_VAR__)))))))))))
+                      (StaticMethodCall
+                       (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) Constant ()
+                       ((Literal 2) (Literal 3) (Var DUMMY_VAR__)))))))))))
               (Expression (Assign (Var current_statement__) (Literal 16)))
               (Expression
                (Assign (Var p_ar_mat)
                 (MethodCall (Var in__) "template read_constrain_lub"
                  ((StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                   AoS)
                   (TemplateType jacobian__))
                  ((Literal 0) (Literal 1) (Var lp__) (Literal 4) (Literal 5) 
                   (Literal 2) (Literal 3)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS))
                 (name p_simplex)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 17)))
               (Expression
                (Assign (Var p_simplex)
                 (MethodCall (Var in__) "template read_constrain_simplex"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                 (name p_1d_simplex)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (Expression (Assign (Var current_statement__) (Literal 18)))
               (Expression
                (Assign (Var p_1d_simplex)
                 (MethodCall (Var in__) "template read_constrain_simplex"
-                 ((StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                 ((StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Var N) (Var N)))))
               (VariableDefn
@@ -5995,24 +6322,31 @@
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name p_3d_simplex)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 19)))
               (Expression
@@ -6020,296 +6354,341 @@
                 (MethodCall (Var in__) "template read_constrain_simplex"
                  ((StdVector
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                    AoS)
+                   AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Var N) (Var M) (Var K) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name p_cfcov_54)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 5) (Literal 4) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 20)))
               (Expression
                (Assign (Var p_cfcov_54)
                 (MethodCall (Var in__) "template read_constrain_cholesky_factor_cov"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Literal 5) (Literal 4)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name p_cfcov_33)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 21)))
               (Expression
                (Assign (Var p_cfcov_33)
                 (MethodCall (Var in__) "template read_constrain_cholesky_factor_cov"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Literal 3) (Literal 3)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS))
                 (name p_cfcov_33_ar)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
                    ((Var K)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
-                     Constant () ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) Constant ()
+                     ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))))
               (Expression (Assign (Var current_statement__) (Literal 22)))
               (Expression
                (Assign (Var p_cfcov_33_ar)
                 (MethodCall (Var in__) "template read_constrain_cholesky_factor_cov"
-                 ((StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                 ((StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Var K) (Literal 3) (Literal 3)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                 (name x_p)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Literal 2) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 23)))
               (Expression
                (Assign (Var x_p)
                 (MethodCall (Var in__) "template read"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) ((Literal 2)))))
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
+                 ((Literal 2)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                 (name y_p)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Literal 2) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 24)))
               (Expression
                (Assign (Var y_p)
                 (MethodCall (Var in__) "template read"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) ((Literal 2)))))
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
+                 ((Literal 2)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__))) (name tp_real_1d_ar)
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+                (name tp_real_1d_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Var N) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
-                 (StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__)))))
+                 (StdVector
+                  (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS) AoS))
                 (name tp_real_3d_ar)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__))))
+                   (StdVector
+                    (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
+                    AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (TypeLiteral local_scalar_t__)))
+                    (Constructor
+                     (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                      (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                        ((Var K) (Var DUMMY_VAR__)))))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS))
                 (name tp_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                 (name tp_1d_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name tp_3d_vec)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS))
                 (name tp_row_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS))
                 (name tp_1d_row_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name tp_3d_row_vec)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name tp_mat)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 5) (Literal 4) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
-                  (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))))
+                  (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                  AoS))
                 (name tp_ar_mat)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                    AoS)
                    ((Literal 4)
                     (Constructor
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
+                      AoS)
                      ((Literal 5)
-                      (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
-                       Constant () ((Literal 2) (Literal 3) (Var DUMMY_VAR__)))))))))))
+                      (StaticMethodCall
+                       (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) Constant ()
+                       ((Literal 2) (Literal 3) (Var DUMMY_VAR__)))))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS))
                 (name tp_simplex)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                 (name tp_1d_simplex)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name tp_3d_simplex)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name tp_cfcov_54)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 5) (Literal 4) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name tp_cfcov_33)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS))
                 (name tp_cfcov_33_ar)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
                    ((Var K)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
-                     Constant () ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) Constant ()
+                     ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS))
                 (name theta_p)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Literal 2) (Var DUMMY_VAR__)))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name tp_real) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name tp_real)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 70)))
               (Expression
                (FunCall stan::model::assign ()
@@ -6374,25 +6753,25 @@
                  (Literal "\"assigning variable tp_vec\""))))
               (Expression (Assign (Var current_statement__) (Literal 90)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name i)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name i)
                 (init (Assignment (Literal 1))))
                (BinOp (Var i) LEq (Literal 2)) (Increment (Var i))
                (Block
                 ((Expression (Assign (Var current_statement__) (Literal 88)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name j)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name j) (init (Assignment (Literal 1))))
                   (BinOp (Var j) LEq (Literal 3)) (Increment (Var j))
                   (Block
                    ((Expression (Assign (Var current_statement__) (Literal 86)))
                     (For
-                     ((static false) (constexpr false) (type_ Int) (name m)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name m) (init (Assignment (Literal 1))))
                      (BinOp (Var m) LEq (Literal 4)) (Increment (Var m))
                      (Block
                       ((Expression (Assign (Var current_statement__) (Literal 84)))
                        (For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name n) (init (Assignment (Literal 1))))
                         (BinOp (Var n) LEq (Literal 5)) (Increment (Var n))
                         (Block
@@ -6407,7 +6786,7 @@
                              (FunCall stan::model::index_uni () ((Var j))))))))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 92)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name i)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name i)
                 (init (Assignment (Literal 1))))
                (BinOp (Var i) LEq (Var N)) (Increment (Var i))
                (Block
@@ -6556,32 +6935,37 @@
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                  (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                   (name tmp)
                   (init
                    (Assignment
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Literal 0) (Var DUMMY_VAR__)))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Literal 0) (Var DUMMY_VAR__)))))))
                 (VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                  (type_
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                   (name tmp2)
                   (init
                    (Assignment
                     (Constructor
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                      ((Literal 0)
-                      (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                       Constant () ((Literal 0) (Var DUMMY_VAR__)))))))))
+                      (StaticMethodCall
+                       (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                       ((Literal 0) (Var DUMMY_VAR__)))))))))
                 (VariableDefn
-                 ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                  (name r1) (init (Assignment (Var DUMMY_VAR__)))))
+                 ((static false) (constexpr false)
+                  (type_ (TypeLiteral local_scalar_t__ AoS)) (name r1)
+                  (init (Assignment (Var DUMMY_VAR__)))))
                 (Expression (Assign (Var current_statement__) (Literal 156)))
                 (Expression
                  (Assign (Var r1) (FunCall foo_bar1 () ((Var p_real) (Var pstream__)))))
                 (VariableDefn
-                 ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                  (name r2) (init (Assignment (Var DUMMY_VAR__)))))
+                 ((static false) (constexpr false)
+                  (type_ (TypeLiteral local_scalar_t__ AoS)) (name r2)
+                  (init (Assignment (Var DUMMY_VAR__)))))
                 (Expression (Assign (Var current_statement__) (Literal 157)))
                 (Expression
                  (Assign (Var r2) (FunCall foo_bar1 () ((Var J) (Var pstream__)))))
@@ -6613,8 +6997,8 @@
                      (Literal 0) (Literal 1))))))
                 (Expression (Assign (Var current_statement__) (Literal 175)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name n)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name n) (init (Assignment (Literal 1))))
                  (BinOp (Var n) LEq (Var N)) (Increment (Var n))
                  (Block
                   ((Expression (Assign (Var current_statement__) (Literal 163)))
@@ -6646,13 +7030,13 @@
                         (Literal 0) (Literal 1))))))
                    (Expression (Assign (Var current_statement__) (Literal 173)))
                    (For
-                    ((static false) (constexpr false) (type_ Int) (name m)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name m) (init (Assignment (Literal 1))))
                     (BinOp (Var m) LEq (Var M)) (Increment (Var m))
                     (Block
                      ((Expression (Assign (Var current_statement__) (Literal 171)))
                       (For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name k) (init (Assignment (Literal 1))))
                        (BinOp (Var k) LEq (Var K)) (Increment (Var k))
                        (Block
@@ -6721,14 +7105,14 @@
                               (Literal 1)))))))))))))))
                 (Expression (Assign (Var current_statement__) (Literal 180)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name i)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name i) (init (Assignment (Literal 1))))
                  (BinOp (Var i) LEq (Literal 4)) (Increment (Var i))
                  (Block
                   ((Expression (Assign (Var current_statement__) (Literal 178)))
                    (For
-                    ((static false) (constexpr false) (type_ Int) (name j)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name j) (init (Assignment (Literal 1))))
                     (BinOp (Var j) LEq (Literal 5)) (Increment (Var j))
                     (Block
                      ((Expression (Assign (Var current_statement__) (Literal 176)))
@@ -6743,8 +7127,8 @@
                            (Literal 0) (Literal 1))))))))))))
                 (Expression (Assign (Var current_statement__) (Literal 183)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name k)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name k) (init (Assignment (Literal 1))))
                  (BinOp (Var k) LEq (Var K)) (Increment (Var k))
                  (Block
                   ((Expression (Assign (Var current_statement__) (Literal 181)))
@@ -6791,7 +7175,7 @@
                  (MethodCall (Var lp_accum__) add ()
                   ((FunCall "stan::math::map_rect<1, binomialf_functor__>" ()
                     ((Var tmp) (Var tmp2) (Var x_r) (Var x_i) (Var pstream__)))))))))
-             ((Const (Ref (TypeLiteral std::exception))) e)
+             ((Const (Ref (TypeLiteral std::exception AoS))) e)
              ((Expression
                (FunCall stan::lang::rethrow_located ()
                 ((Var e) (Index (Var locations_array__) (Var current_statement__)))))))
@@ -6808,197 +7192,215 @@
          (args
           (((Ref (TemplateType RNG)) base_rng__) ((Ref (TemplateType VecR)) params_r__)
            ((Ref (TemplateType VecI)) params_i__) ((Ref (TemplateType VecVar)) vars__)
-           ((Const (TypeLiteral bool)) "emit_transformed_parameters__ = true")
-           ((Const (TypeLiteral bool)) "emit_generated_quantities__ = true")
-           ((Pointer (TypeLiteral std::ostream)) "pstream__ = nullptr")))
+           ((Const (TypeLiteral bool AoS)) "emit_transformed_parameters__ = true")
+           ((Const (TypeLiteral bool AoS)) "emit_generated_quantities__ = true")
+           ((Pointer (TypeLiteral std::ostream AoS)) "pstream__ = nullptr")))
          (cv_qualifiers (Const))
          (body
-          (((Using local_scalar_t__ (Double))
+          (((Using local_scalar_t__ ((Double AoS)))
             (VariableDefn
              ((static false) (constexpr false)
-              (type_ (TypeTrait stan::io::deserializer ((TypeLiteral local_scalar_t__))))
+              (type_
+               (TypeTrait stan::io::deserializer ((TypeLiteral local_scalar_t__ AoS))))
               (name in__) (init (Construction ((Var params_r__) (Var params_i__))))))
             (VariableDefn
              ((static false) (constexpr false)
-              (type_ (TypeTrait stan::io::serializer ((TypeLiteral local_scalar_t__))))
+              (type_
+               (TypeTrait stan::io::serializer ((TypeLiteral local_scalar_t__ AoS))))
               (name out__) (init (Construction ((Var vars__))))))
             (VariableDefn
-             ((static true) (constexpr true) (type_ (TypeLiteral bool)) 
+             ((static true) (constexpr true) (type_ (TypeLiteral bool AoS))
               (name propto__) (init (Assignment (Literal true)))))
             (Comment "suppress unused var warning")
             (Expression (Cast Void (Var propto__)))
             (VariableDefn
-             ((static false) (constexpr false) (type_ Double) (name lp__)
+             ((static false) (constexpr false) (type_ (Double AoS)) (name lp__)
               (init (Assignment (Literal 0.0)))))
             (Comment "suppress unused var warning") (Expression (Cast Void (Var lp__)))
             (VariableDefn
-             ((static false) (constexpr false) (type_ Int) (name current_statement__)
-              (init (Assignment (Literal 0)))))
+             ((static false) (constexpr false) (type_ (Int AoS))
+              (name current_statement__) (init (Assignment (Literal 0)))))
             (VariableDefn
              ((static false) (constexpr false)
-              (type_ (TypeTrait stan::math::accumulator (Double))) (name lp_accum__)
-              (init Uninitialized)))
+              (type_ (TypeTrait stan::math::accumulator ((Double AoS))))
+              (name lp_accum__) (init Uninitialized)))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+             ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
               (name DUMMY_VAR__)
               (init
                (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
             (Comment "suppress unused var warning")
             (Expression (Cast Void (Var DUMMY_VAR__)))
             (VariableDefn
-             ((static false) (constexpr true) (type_ (TypeLiteral bool))
+             ((static false) (constexpr true) (type_ (TypeLiteral bool AoS))
               (name jacobian__) (init (Assignment (Literal false)))))
             (Comment "suppress unused var warning")
             (Expression (Cast Void (Var jacobian__)))
             (VariableDefn
-             ((static true) (constexpr true) (type_ (Const (Pointer (TypeLiteral char))))
-              (name function__)
+             ((static true) (constexpr true)
+              (type_ (Const (Pointer (TypeLiteral char AoS)))) (name function__)
               (init (Assignment (Literal "\"mother_model_namespace::write_array\"")))))
             (Comment "suppress unused var warning")
             (Expression (Cast Void (Var function__)))
             (TryCatch
              ((VariableDefn
-               ((static false) (constexpr false) (type_ Double) (name p_real)
+               ((static false) (constexpr false) (type_ (Double AoS)) 
+                (name p_real)
                 (init
                  (Assignment (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
               (Expression (Assign (Var current_statement__) (Literal 1)))
               (Expression
                (Assign (Var p_real)
-                (MethodCall (Var in__) "template read" ((TypeLiteral local_scalar_t__))
-                 ())))
+                (MethodCall (Var in__) "template read"
+                 ((TypeLiteral local_scalar_t__ AoS)) ())))
               (VariableDefn
-               ((static false) (constexpr false) (type_ Double) (name p_upper)
+               ((static false) (constexpr false) (type_ (Double AoS)) 
+                (name p_upper)
                 (init
                  (Assignment (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
               (Expression (Assign (Var current_statement__) (Literal 2)))
               (Expression
                (Assign (Var p_upper)
                 (MethodCall (Var in__) "template read_constrain_lb"
-                 ((TypeLiteral local_scalar_t__) (TemplateType jacobian__))
+                 ((TypeLiteral local_scalar_t__ AoS) (TemplateType jacobian__))
                  ((Var p_real) (Var lp__)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ Double) (name p_lower)
+               ((static false) (constexpr false) (type_ (Double AoS)) 
+                (name p_lower)
                 (init
                  (Assignment (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
               (Expression (Assign (Var current_statement__) (Literal 3)))
               (Expression
                (Assign (Var p_lower)
                 (MethodCall (Var in__) "template read_constrain_ub"
-                 ((TypeLiteral local_scalar_t__) (TemplateType jacobian__))
+                 ((TypeLiteral local_scalar_t__ AoS) (TemplateType jacobian__))
                  ((Var p_upper) (Var lp__)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (StdVector Double))
+               ((static false) (constexpr false) (type_ (StdVector (Double AoS) AoS))
                 (name offset_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector Double)
+                  (Constructor (StdVector (Double AoS) AoS)
                    ((Literal 5) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (Expression (Assign (Var current_statement__) (Literal 4)))
               (Expression
                (Assign (Var offset_multiplier)
                 (MethodCall (Var in__) "template read_constrain_offset_multiplier"
-                 ((StdVector (TypeLiteral local_scalar_t__)) (TemplateType jacobian__))
+                 ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
+                  (TemplateType jacobian__))
                  ((Literal 1) (Literal 2) (Var lp__) (Literal 5)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (StdVector Double))
+               ((static false) (constexpr false) (type_ (StdVector (Double AoS) AoS))
                 (name no_offset_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector Double)
+                  (Constructor (StdVector (Double AoS) AoS)
                    ((Literal 5) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (Expression (Assign (Var current_statement__) (Literal 5)))
               (Expression
                (Assign (Var no_offset_multiplier)
                 (MethodCall (Var in__) "template read_constrain_offset_multiplier"
-                 ((StdVector (TypeLiteral local_scalar_t__)) (TemplateType jacobian__))
+                 ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
+                  (TemplateType jacobian__))
                  ((Literal 0) (Literal 2) (Var lp__) (Literal 5)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (StdVector Double))
+               ((static false) (constexpr false) (type_ (StdVector (Double AoS) AoS))
                 (name offset_no_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector Double)
+                  (Constructor (StdVector (Double AoS) AoS)
                    ((Literal 5) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (Expression (Assign (Var current_statement__) (Literal 6)))
               (Expression
                (Assign (Var offset_no_multiplier)
                 (MethodCall (Var in__) "template read_constrain_offset_multiplier"
-                 ((StdVector (TypeLiteral local_scalar_t__)) (TemplateType jacobian__))
+                 ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
+                  (TemplateType jacobian__))
                  ((Literal 3) (Literal 1) (Var lp__) (Literal 5)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (StdVector Double))
+               ((static false) (constexpr false) (type_ (StdVector (Double AoS) AoS))
                 (name p_real_1d_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector Double)
+                  (Constructor (StdVector (Double AoS) AoS)
                    ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (Expression (Assign (Var current_statement__) (Literal 7)))
               (Expression
                (Assign (Var p_real_1d_ar)
                 (MethodCall (Var in__) "template read_constrain_lb"
-                 ((StdVector (TypeLiteral local_scalar_t__)) (TemplateType jacobian__))
+                 ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
+                  (TemplateType jacobian__))
                  ((Literal 0) (Var lp__) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (StdVector Double)))) (name p_real_3d_ar)
+                (type_ (StdVector (StdVector (StdVector (Double AoS) AoS) AoS) AoS))
+                (name p_real_3d_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector (StdVector (StdVector Double)))
+                  (Constructor
+                   (StdVector (StdVector (StdVector (Double AoS) AoS) AoS) AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector Double))
+                    (Constructor (StdVector (StdVector (Double AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector Double)
+                      (Constructor (StdVector (Double AoS) AoS)
                        ((Var K) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
               (Expression (Assign (Var current_statement__) (Literal 8)))
               (Expression
                (Assign (Var p_real_3d_ar)
                 (MethodCall (Var in__) "template read_constrain_lb"
-                 ((StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__))))
+                 ((StdVector
+                   (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
+                   AoS)
                   (TemplateType jacobian__))
                  ((Literal 0) (Var lp__) (Var N) (Var M) (Var K)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
                 (name p_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                    ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (Expression (Assign (Var current_statement__) (Literal 9)))
               (Expression
                (Assign (Var p_vec)
                 (MethodCall (Var in__) "template read_constrain_lb"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                   (TemplateType jacobian__))
                  ((Literal 0) (Var lp__) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 1 AoS))) (name p_1d_vec)
+                (type_ (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)) 
+                (name p_1d_vec)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                      ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (Expression (Assign (Var current_statement__) (Literal 10)))
               (Expression
                (Assign (Var p_1d_vec)
                 (MethodCall (Var in__) "template read"
-                 ((StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                 ((StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                  ((Var N) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS)))))
+                (type_
+                 (StdVector
+                  (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS))
                 (name p_3d_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS))))
+                   (StdVector
+                    (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (Matrix Double -1 1 AoS)))
+                    (Constructor
+                     (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (Matrix Double -1 1 AoS))
+                      (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                        ((Var K)
-                        (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                        (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                          ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 11)))
               (Expression
@@ -7006,49 +7408,57 @@
                 (MethodCall (Var in__) "template read"
                  ((StdVector
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                    AoS)
+                   AoS))
                  ((Var N) (Var M) (Var K) (Var N)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double 1 -1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) 1 -1 AoS))
                 (name p_row_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                    ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (Expression (Assign (Var current_statement__) (Literal 12)))
               (Expression
                (Assign (Var p_row_vec)
                 (MethodCall (Var in__) "template read"
-                 ((Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)) ((Var N)))))
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)) 
+                 ((Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double 1 -1 AoS))) (name p_1d_row_vec)
+                (type_ (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS))
+                (name p_1d_row_vec)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double 1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                      ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (Expression (Assign (Var current_statement__) (Literal 13)))
               (Expression
                (Assign (Var p_1d_row_vec)
                 (MethodCall (Var in__) "template read"
-                 ((StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                 ((StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS))
                  ((Var N) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (StdVector (Matrix Double 1 -1 AoS)))))
+                (type_
+                 (StdVector
+                  (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS) AoS))
                 (name p_3d_row_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (Matrix Double 1 -1 AoS))))
+                   (StdVector
+                    (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS) AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (Matrix Double 1 -1 AoS)))
+                    (Constructor
+                     (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (Matrix Double 1 -1 AoS))
+                      (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
                        ((Var K)
-                        (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                        (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                          ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 14)))
               (Expression
@@ -7056,33 +7466,36 @@
                 (MethodCall (Var in__) "template read"
                  ((StdVector
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                    AoS)
+                   AoS))
                  ((Var N) (Var M) (Var K) (Var N)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
                 (name p_mat)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                    ((Literal 5) (Literal 4)
                     (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (Expression (Assign (Var current_statement__) (Literal 15)))
               (Expression
                (Assign (Var p_mat)
                 (MethodCall (Var in__) "template read"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                  ((Literal 5) (Literal 4)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (Matrix Double -1 -1 AoS)))) 
+                (type_ (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS))
                 (name p_ar_mat)
                 (init
                  (Assignment
-                  (Constructor (StdVector (StdVector (Matrix Double -1 -1 AoS)))
+                  (Constructor
+                   (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS)
                    ((Literal 4)
-                    (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                    (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                      ((Literal 5)
-                      (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                      (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                        ((Literal 2) (Literal 3)
                         (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
               (Expression (Assign (Var current_statement__) (Literal 16)))
@@ -7090,54 +7503,60 @@
                (Assign (Var p_ar_mat)
                 (MethodCall (Var in__) "template read_constrain_lub"
                  ((StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                   AoS)
                   (TemplateType jacobian__))
                  ((Literal 0) (Literal 1) (Var lp__) (Literal 4) (Literal 5) 
                   (Literal 2) (Literal 3)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
                 (name p_simplex)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                    ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (Expression (Assign (Var current_statement__) (Literal 17)))
               (Expression
                (Assign (Var p_simplex)
                 (MethodCall (Var in__) "template read_constrain_simplex"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 1 AoS))) (name p_1d_simplex)
+                (type_ (StdVector (Matrix (Double AoS) -1 1 AoS) AoS))
+                (name p_1d_simplex)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                      ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (Expression (Assign (Var current_statement__) (Literal 18)))
               (Expression
                (Assign (Var p_1d_simplex)
                 (MethodCall (Var in__) "template read_constrain_simplex"
-                 ((StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                 ((StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Var N) (Var N)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS)))))
+                (type_
+                 (StdVector
+                  (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS))
                 (name p_3d_simplex)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS))))
+                   (StdVector
+                    (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (Matrix Double -1 1 AoS)))
+                    (Constructor
+                     (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (Matrix Double -1 1 AoS))
+                      (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                        ((Var K)
-                        (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                        (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                          ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 19)))
               (Expression
@@ -7145,247 +7564,272 @@
                 (MethodCall (Var in__) "template read_constrain_simplex"
                  ((StdVector
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                    AoS)
+                   AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Var N) (Var M) (Var K) (Var N)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
                 (name p_cfcov_54)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                    ((Literal 5) (Literal 4)
                     (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (Expression (Assign (Var current_statement__) (Literal 20)))
               (Expression
                (Assign (Var p_cfcov_54)
                 (MethodCall (Var in__) "template read_constrain_cholesky_factor_cov"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Literal 5) (Literal 4)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
                 (name p_cfcov_33)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                    ((Literal 3) (Literal 3)
                     (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (Expression (Assign (Var current_statement__) (Literal 21)))
               (Expression
                (Assign (Var p_cfcov_33)
                 (MethodCall (Var in__) "template read_constrain_cholesky_factor_cov"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Literal 3) (Literal 3)))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 -1 AoS))) (name p_cfcov_33_ar)
+                (type_ (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS))
+                (name p_cfcov_33_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                    ((Var K)
-                    (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                      ((Literal 3) (Literal 3)
                       (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (Expression (Assign (Var current_statement__) (Literal 22)))
               (Expression
                (Assign (Var p_cfcov_33_ar)
                 (MethodCall (Var in__) "template read_constrain_cholesky_factor_cov"
-                 ((StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                 ((StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
                   (TemplateType jacobian__))
                  ((Var lp__) (Var K) (Literal 3) (Literal 3)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
                 (name x_p)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                    ((Literal 2) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (Expression (Assign (Var current_statement__) (Literal 23)))
               (Expression
                (Assign (Var x_p)
                 (MethodCall (Var in__) "template read"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) ((Literal 2)))))
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
+                 ((Literal 2)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
                 (name y_p)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                    ((Literal 2) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (Expression (Assign (Var current_statement__) (Literal 24)))
               (Expression
                (Assign (Var y_p)
                 (MethodCall (Var in__) "template read"
-                 ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) ((Literal 2)))))
+                 ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
+                 ((Literal 2)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (StdVector Double))
+               ((static false) (constexpr false) (type_ (StdVector (Double AoS) AoS))
                 (name tp_real_1d_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector Double)
+                  (Constructor (StdVector (Double AoS) AoS)
                    ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (StdVector Double)))) (name tp_real_3d_ar)
+                (type_ (StdVector (StdVector (StdVector (Double AoS) AoS) AoS) AoS))
+                (name tp_real_3d_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector (StdVector (StdVector Double)))
+                  (Constructor
+                   (StdVector (StdVector (StdVector (Double AoS) AoS) AoS) AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector Double))
+                    (Constructor (StdVector (StdVector (Double AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector Double)
+                      (Constructor (StdVector (Double AoS) AoS)
                        ((Var K) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
                 (name tp_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                    ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 1 AoS))) (name tp_1d_vec)
+                (type_ (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)) 
+                (name tp_1d_vec)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                      ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS)))))
+                (type_
+                 (StdVector
+                  (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS))
                 (name tp_3d_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS))))
+                   (StdVector
+                    (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (Matrix Double -1 1 AoS)))
+                    (Constructor
+                     (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (Matrix Double -1 1 AoS))
+                      (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                        ((Var K)
-                        (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                        (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                          ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double 1 -1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) 1 -1 AoS))
                 (name tp_row_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                    ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double 1 -1 AoS))) (name tp_1d_row_vec)
+                (type_ (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS))
+                (name tp_1d_row_vec)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double 1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                      ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (StdVector (Matrix Double 1 -1 AoS)))))
+                (type_
+                 (StdVector
+                  (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS) AoS))
                 (name tp_3d_row_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (Matrix Double 1 -1 AoS))))
+                   (StdVector
+                    (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS) AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (Matrix Double 1 -1 AoS)))
+                    (Constructor
+                     (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (Matrix Double 1 -1 AoS))
+                      (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
                        ((Var K)
-                        (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                        (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                          ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
                 (name tp_mat)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                    ((Literal 5) (Literal 4)
                     (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (Matrix Double -1 -1 AoS))))
+                (type_ (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS))
                 (name tp_ar_mat)
                 (init
                  (Assignment
-                  (Constructor (StdVector (StdVector (Matrix Double -1 -1 AoS)))
+                  (Constructor
+                   (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS)
                    ((Literal 4)
-                    (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                    (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                      ((Literal 5)
-                      (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                      (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                        ((Literal 2) (Literal 3)
                         (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
                 (name tp_simplex)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                    ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 1 AoS))) (name tp_1d_simplex)
+                (type_ (StdVector (Matrix (Double AoS) -1 1 AoS) AoS))
+                (name tp_1d_simplex)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                      ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS)))))
+                (type_
+                 (StdVector
+                  (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS))
                 (name tp_3d_simplex)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS))))
+                   (StdVector
+                    (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (Matrix Double -1 1 AoS)))
+                    (Constructor
+                     (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (Matrix Double -1 1 AoS))
+                      (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                        ((Var K)
-                        (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                        (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                          ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
                 (name tp_cfcov_54)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                    ((Literal 5) (Literal 4)
                     (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
                 (name tp_cfcov_33)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                    ((Literal 3) (Literal 3)
                     (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 -1 AoS))) (name tp_cfcov_33_ar)
+                (type_ (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS))
+                (name tp_cfcov_33_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                    ((Var K)
-                    (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                      ((Literal 3) (Literal 3)
                       (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
                 (name theta_p)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                    ((Literal 2) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ Double) (name tp_real)
+               ((static false) (constexpr false) (type_ (Double AoS)) 
+                (name tp_real)
                 (init
                  (Assignment (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
               (Expression (MethodCall (Var out__) write () ((Var p_real))))
@@ -7397,18 +7841,18 @@
               (Expression (MethodCall (Var out__) write () ((Var p_real_1d_ar))))
               (Expression (Assign (Var current_statement__) (Literal 8)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var K)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var M)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var N)) (Increment (Var sym3__))
                      (Block
                       ((Expression
@@ -7422,13 +7866,13 @@
               (Expression (MethodCall (Var out__) write () ((Var p_vec))))
               (Expression (Assign (Var current_statement__) (Literal 10)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                   (Block
                    ((Expression
@@ -7439,22 +7883,22 @@
                         (Parens (BinOp (Var sym1__) Subtract (Literal 1)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 11)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym4__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                         (Block
@@ -7471,13 +7915,13 @@
               (Expression (MethodCall (Var out__) write () ((Var p_row_vec))))
               (Expression (Assign (Var current_statement__) (Literal 13)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                   (Block
                    ((Expression
@@ -7488,22 +7932,22 @@
                         (Parens (BinOp (Var sym1__) Subtract (Literal 1)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 14)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym4__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                         (Block
@@ -7520,22 +7964,22 @@
               (Expression (MethodCall (Var out__) write () ((Var p_mat))))
               (Expression (Assign (Var current_statement__) (Literal 16)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym4__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym4__) LEq (Literal 4)) (Increment (Var sym4__))
                         (Block
@@ -7550,13 +7994,13 @@
               (Expression (MethodCall (Var out__) write () ((Var p_simplex))))
               (Expression (Assign (Var current_statement__) (Literal 18)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                   (Block
                    ((Expression
@@ -7567,22 +8011,22 @@
                         (Parens (BinOp (Var sym1__) Subtract (Literal 1)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 19)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym4__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                         (Block
@@ -7600,18 +8044,18 @@
               (Expression (MethodCall (Var out__) write () ((Var p_cfcov_33))))
               (Expression (Assign (Var current_statement__) (Literal 22)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var K)) (Increment (Var sym3__))
                      (Block
                       ((Expression
@@ -7697,25 +8141,25 @@
                  (Literal "\"assigning variable tp_vec\""))))
               (Expression (Assign (Var current_statement__) (Literal 90)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name i)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name i)
                 (init (Assignment (Literal 1))))
                (BinOp (Var i) LEq (Literal 2)) (Increment (Var i))
                (Block
                 ((Expression (Assign (Var current_statement__) (Literal 88)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name j)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name j) (init (Assignment (Literal 1))))
                   (BinOp (Var j) LEq (Literal 3)) (Increment (Var j))
                   (Block
                    ((Expression (Assign (Var current_statement__) (Literal 86)))
                     (For
-                     ((static false) (constexpr false) (type_ Int) (name m)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name m) (init (Assignment (Literal 1))))
                      (BinOp (Var m) LEq (Literal 4)) (Increment (Var m))
                      (Block
                       ((Expression (Assign (Var current_statement__) (Literal 84)))
                        (For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name n) (init (Assignment (Literal 1))))
                         (BinOp (Var n) LEq (Literal 5)) (Increment (Var n))
                         (Block
@@ -7730,7 +8174,7 @@
                              (FunCall stan::model::index_uni () ((Var j))))))))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 92)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name i)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name i)
                 (init (Assignment (Literal 1))))
                (BinOp (Var i) LEq (Var N)) (Increment (Var i))
                (Block
@@ -7881,17 +8325,17 @@
                 ((Expression (MethodCall (Var out__) write () ((Var tp_real_1d_ar))))
                  (Expression (Assign (Var current_statement__) (Literal 26)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name sym1__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym1__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym1__) LEq (Var K)) (Increment (Var sym1__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym2__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym2__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym2__) LEq (Var M)) (Increment (Var sym2__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym3__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym3__) LEq (Var N)) (Increment (Var sym3__))
                         (Block
@@ -7906,13 +8350,13 @@
                  (Expression (MethodCall (Var out__) write () ((Var tp_vec))))
                  (Expression (Assign (Var current_statement__) (Literal 28)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name sym1__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym1__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym2__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym2__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                      (Block
                       ((Expression
@@ -7923,22 +8367,22 @@
                            (Parens (BinOp (Var sym1__) Subtract (Literal 1)))))))))))))
                  (Expression (Assign (Var current_statement__) (Literal 29)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name sym1__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym1__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym2__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym2__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym3__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                         (Block
                          ((For
-                           ((static false) (constexpr false) (type_ Int) 
+                           ((static false) (constexpr false) (type_ (Int AoS))
                             (name sym4__) (init (Assignment (Literal 1))))
                            (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                            (Block
@@ -7955,13 +8399,13 @@
                  (Expression (MethodCall (Var out__) write () ((Var tp_row_vec))))
                  (Expression (Assign (Var current_statement__) (Literal 31)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name sym1__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym1__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym2__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym2__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                      (Block
                       ((Expression
@@ -7972,22 +8416,22 @@
                            (Parens (BinOp (Var sym1__) Subtract (Literal 1)))))))))))))
                  (Expression (Assign (Var current_statement__) (Literal 32)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name sym1__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym1__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym2__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym2__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym3__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                         (Block
                          ((For
-                           ((static false) (constexpr false) (type_ Int) 
+                           ((static false) (constexpr false) (type_ (Int AoS))
                             (name sym4__) (init (Assignment (Literal 1))))
                            (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                            (Block
@@ -8004,22 +8448,22 @@
                  (Expression (MethodCall (Var out__) write () ((Var tp_mat))))
                  (Expression (Assign (Var current_statement__) (Literal 34)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name sym1__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym1__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym2__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym2__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym3__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                         (Block
                          ((For
-                           ((static false) (constexpr false) (type_ Int) 
+                           ((static false) (constexpr false) (type_ (Int AoS))
                             (name sym4__) (init (Assignment (Literal 1))))
                            (BinOp (Var sym4__) LEq (Literal 4)) (Increment (Var sym4__))
                            (Block
@@ -8034,13 +8478,13 @@
                  (Expression (MethodCall (Var out__) write () ((Var tp_simplex))))
                  (Expression (Assign (Var current_statement__) (Literal 36)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name sym1__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym1__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym2__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym2__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                      (Block
                       ((Expression
@@ -8051,22 +8495,22 @@
                            (Parens (BinOp (Var sym1__) Subtract (Literal 1)))))))))))))
                  (Expression (Assign (Var current_statement__) (Literal 37)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name sym1__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym1__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym2__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym2__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym3__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                         (Block
                          ((For
-                           ((static false) (constexpr false) (type_ Int) 
+                           ((static false) (constexpr false) (type_ (Int AoS))
                             (name sym4__) (init (Assignment (Literal 1))))
                            (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                            (Block
@@ -8084,17 +8528,17 @@
                  (Expression (MethodCall (Var out__) write () ((Var tp_cfcov_33))))
                  (Expression (Assign (Var current_statement__) (Literal 40)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name sym1__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym1__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym2__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym2__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym3__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym3__) LEq (Var K)) (Increment (Var sym3__))
                         (Block
@@ -8113,269 +8557,300 @@
                 ((Var emit_generated_quantities__)))
                (Block ((Return ()))) ())
               (VariableDefn
-               ((static false) (constexpr false) (type_ Double) (name gq_r1)
+               ((static false) (constexpr false) (type_ (Double AoS)) 
+                (name gq_r1)
                 (init
                  (Assignment (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
               (Expression (Assign (Var current_statement__) (Literal 43)))
               (Expression
                (Assign (Var gq_r1) (FunCall foo_bar1 () ((Var p_real) (Var pstream__)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ Double) (name gq_r2)
+               ((static false) (constexpr false) (type_ (Double AoS)) 
+                (name gq_r2)
                 (init
                  (Assignment (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
               (Expression (Assign (Var current_statement__) (Literal 44)))
               (Expression
                (Assign (Var gq_r2) (FunCall foo_bar1 () ((Var J) (Var pstream__)))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (StdVector Double))
+               ((static false) (constexpr false) (type_ (StdVector (Double AoS) AoS))
                 (name gq_real_1d_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector Double)
+                  (Constructor (StdVector (Double AoS) AoS)
                    ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (StdVector Double)))) (name gq_real_3d_ar)
+                (type_ (StdVector (StdVector (StdVector (Double AoS) AoS) AoS) AoS))
+                (name gq_real_3d_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector (StdVector (StdVector Double)))
+                  (Constructor
+                   (StdVector (StdVector (StdVector (Double AoS) AoS) AoS) AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector Double))
+                    (Constructor (StdVector (StdVector (Double AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector Double)
+                      (Constructor (StdVector (Double AoS) AoS)
                        ((Var K) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
                 (name gq_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                    ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 1 AoS))) (name gq_1d_vec)
+                (type_ (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)) 
+                (name gq_1d_vec)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                      ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS)))))
+                (type_
+                 (StdVector
+                  (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS))
                 (name gq_3d_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS))))
+                   (StdVector
+                    (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (Matrix Double -1 1 AoS)))
+                    (Constructor
+                     (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (Matrix Double -1 1 AoS))
+                      (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                        ((Var K)
-                        (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                        (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                          ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double 1 -1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) 1 -1 AoS))
                 (name gq_row_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                    ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double 1 -1 AoS))) (name gq_1d_row_vec)
+                (type_ (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS))
+                (name gq_1d_row_vec)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double 1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                      ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (StdVector (Matrix Double 1 -1 AoS)))))
+                (type_
+                 (StdVector
+                  (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS) AoS))
                 (name gq_3d_row_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (Matrix Double 1 -1 AoS))))
+                   (StdVector
+                    (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS) AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (Matrix Double 1 -1 AoS)))
+                    (Constructor
+                     (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (Matrix Double 1 -1 AoS))
+                      (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
                        ((Var K)
-                        (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                        (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                          ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (Matrix Double -1 -1 AoS))))
+                (type_ (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS))
                 (name gq_ar_mat)
                 (init
                  (Assignment
-                  (Constructor (StdVector (StdVector (Matrix Double -1 -1 AoS)))
+                  (Constructor
+                   (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS)
                    ((Literal 4)
-                    (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                    (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                      ((Literal 5)
-                      (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                      (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                        ((Literal 2) (Literal 3)
                         (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 1 AoS))
                 (name gq_simplex)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                    ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 1 AoS))) (name gq_1d_simplex)
+                (type_ (StdVector (Matrix (Double AoS) -1 1 AoS) AoS))
+                (name gq_1d_simplex)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                      ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS)))))
+                (type_
+                 (StdVector
+                  (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS))
                 (name gq_3d_simplex)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS))))
+                   (StdVector
+                    (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS) AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (Matrix Double -1 1 AoS)))
+                    (Constructor
+                     (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (Matrix Double -1 1 AoS))
+                      (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                        ((Var K)
-                        (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                        (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                          ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
                 (name gq_cfcov_54)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                    ((Literal 5) (Literal 4)
                     (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
+               ((static false) (constexpr false) (type_ (Matrix (Double AoS) -1 -1 AoS))
                 (name gq_cfcov_33)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                  (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                    ((Literal 3) (Literal 3)
                     (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 -1 AoS))) (name gq_cfcov_33_ar)
+                (type_ (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS))
+                (name gq_cfcov_33_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                    ((Var K)
-                    (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                      ((Literal 3) (Literal 3)
                       (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (StdVector Int)) 
+               ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
                 (name indices)
                 (init
                  (Assignment
-                  (Constructor (StdVector Int)
+                  (Constructor (StdVector (Int AoS) AoS)
                    ((Literal 3) (FunCall std::numeric_limits<int>::min () ())))))))
               (Expression (Assign (Var current_statement__) (Literal 60)))
               (Expression
                (FunCall stan::model::assign ()
                 ((Var indices)
-                 (InitializerExpr (StdVector Int) ((Literal 2) (Literal 3) (Literal 1)))
+                 (InitializerExpr (StdVector (Int AoS) AoS)
+                  ((Literal 2) (Literal 3) (Literal 1)))
                  (Literal "\"assigning variable indices\""))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 -1 AoS))) (name indexing_mat)
+                (type_ (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS))
+                (name indexing_mat)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                    ((Literal 5)
-                    (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                      ((Literal 3) (Literal 4)
                       (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 -1 AoS))) (name idx_res1)
+                (type_ (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)) 
+                (name idx_res1)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                    ((Literal 3)
-                    (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                      ((Literal 3) (Literal 4)
                       (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 -1 AoS))) (name idx_res2)
+                (type_ (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)) 
+                (name idx_res2)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                    ((Literal 5)
-                    (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                      ((Literal 3) (Literal 4)
                       (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 -1 AoS))) (name idx_res3)
+                (type_ (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)) 
+                (name idx_res3)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                    ((Literal 3)
-                    (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                      ((Literal 3) (Literal 3)
                       (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 -1 AoS))) (name idx_res11)
+                (type_ (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)) 
+                (name idx_res11)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                    ((Literal 3)
-                    (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                      ((Literal 3) (Literal 4)
                       (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 -1 AoS))) (name idx_res21)
+                (type_ (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)) 
+                (name idx_res21)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                    ((Literal 5)
-                    (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                      ((Literal 3) (Literal 4)
                       (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 -1 AoS))) (name idx_res31)
+                (type_ (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)) 
+                (name idx_res31)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                    ((Literal 3)
-                    (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                      ((Literal 3) (Literal 3)
                       (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double 1 -1 AoS))) (name idx_res4)
+                (type_ (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)) 
+                (name idx_res4)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double 1 -1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
                    ((Literal 3)
-                    (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                      ((Literal 4) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix Double -1 1 AoS))) (name idx_res5)
+                (type_ (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)) 
+                (name idx_res5)
                 (init
                  (Assignment
-                  (Constructor (StdVector (Matrix Double -1 1 AoS))
+                  (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                    ((Literal 2)
-                    (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                    (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                      ((Literal 2) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
               (Expression (Assign (Var current_statement__) (Literal 105)))
               (Expression
@@ -8452,25 +8927,25 @@
                  (Literal "\"assigning variable gq_cfcov_33_ar\""))))
               (Expression (Assign (Var current_statement__) (Literal 126)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name i)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name i)
                 (init (Assignment (Literal 1))))
                (BinOp (Var i) LEq (Literal 2)) (Increment (Var i))
                (Block
                 ((Expression (Assign (Var current_statement__) (Literal 124)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name j)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name j) (init (Assignment (Literal 1))))
                   (BinOp (Var j) LEq (Literal 3)) (Increment (Var j))
                   (Block
                    ((Expression (Assign (Var current_statement__) (Literal 122)))
                     (For
-                     ((static false) (constexpr false) (type_ Int) (name m)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name m) (init (Assignment (Literal 1))))
                      (BinOp (Var m) LEq (Literal 4)) (Increment (Var m))
                      (Block
                       ((Expression (Assign (Var current_statement__) (Literal 120)))
                        (For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name n) (init (Assignment (Literal 1))))
                         (BinOp (Var n) LEq (Literal 5)) (Increment (Var n))
                         (Block
@@ -8485,7 +8960,7 @@
                              (FunCall stan::model::index_uni () ((Var j))))))))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 128)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name i)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name i)
                 (init (Assignment (Literal 1))))
                (BinOp (Var i) LEq (Var N)) (Increment (Var i))
                (Block
@@ -8502,20 +8977,20 @@
                     (FunCall stan::model::index_uni () ((Var i)))))))))
               (Expression (Assign (Var current_statement__) (Literal 132)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name i)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name i)
                 (init (Assignment (Literal 1))))
                (BinOp (Var i) LEq (Literal 3)) (Increment (Var i))
                (Block
                 ((Expression (Assign (Var current_statement__) (Literal 131)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name j)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name j) (init (Assignment (Literal 1))))
                   (BinOp (Var j) LEq (Literal 4)) (Increment (Var j))
                   (Block
                    ((Expression (Assign (Var current_statement__) (Literal 130)))
                     (For
-                     ((static false) (constexpr false) (type_ Int) (name k)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name k) (init (Assignment (Literal 1))))
                      (BinOp (Var k) LEq (Literal 5)) (Increment (Var k))
                      (Block
                       ((Expression (Assign (Var current_statement__) (Literal 129)))
@@ -8530,15 +9005,15 @@
                           (FunCall stan::model::index_uni () ((Var j)))))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 135)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name i)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name i)
                 (init (Assignment (Literal 1))))
                (BinOp (Var i) LEq (FunCall stan::math::size () ((Var indices))))
                (Increment (Var i))
                (Block
                 ((Expression (Assign (Var current_statement__) (Literal 134)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name j)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name j) (init (Assignment (Literal 1))))
                   (BinOp (Var j) LEq (FunCall stan::math::size () ((Var indices))))
                   (Increment (Var j))
                   (Block
@@ -8589,7 +9064,7 @@
                 ((Expression (Assign (Var current_statement__) (Literal 137)))
                  (VariableDefn
                   ((static false) (constexpr false)
-                   (type_ (TypeLiteral std::stringstream)) (name errmsg_stream__)
+                   (type_ (TypeLiteral std::stringstream AoS)) (name errmsg_stream__)
                    (init Uninitialized)))
                  (Expression
                   (FunCall stan::math::stan_print ()
@@ -8600,14 +9075,14 @@
                ())
               (Expression (Assign (Var current_statement__) (Literal 141)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name i)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name i)
                 (init (Assignment (Literal 1))))
                (BinOp (Var i) LEq (Literal 5)) (Increment (Var i))
                (Block
                 ((Expression (Assign (Var current_statement__) (Literal 140)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name j)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name j) (init (Assignment (Literal 1))))
                   (BinOp (Var j) LEq (FunCall stan::math::size () ((Var indices))))
                   (Increment (Var j))
                   (Block
@@ -8655,7 +9130,7 @@
                 ((Expression (Assign (Var current_statement__) (Literal 143)))
                  (VariableDefn
                   ((static false) (constexpr false)
-                   (type_ (TypeLiteral std::stringstream)) (name errmsg_stream__)
+                   (type_ (TypeLiteral std::stringstream AoS)) (name errmsg_stream__)
                    (init Uninitialized)))
                  (Expression
                   (FunCall stan::math::stan_print ()
@@ -8666,21 +9141,21 @@
                ())
               (Expression (Assign (Var current_statement__) (Literal 148)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name i)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name i)
                 (init (Assignment (Literal 1))))
                (BinOp (Var i) LEq (FunCall stan::math::size () ((Var indices))))
                (Increment (Var i))
                (Block
                 ((Expression (Assign (Var current_statement__) (Literal 147)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name j)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name j) (init (Assignment (Literal 1))))
                   (BinOp (Var j) LEq (Literal 3)) (Increment (Var j))
                   (Block
                    ((Expression (Assign (Var current_statement__) (Literal 146)))
                     (For
-                     ((static false) (constexpr false) (type_ Int) (name k)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name k) (init (Assignment (Literal 1))))
                      (BinOp (Var k) LEq (FunCall stan::math::size () ((Var indices))))
                      (Increment (Var k))
                      (Block
@@ -8735,7 +9210,7 @@
                 ((Expression (Assign (Var current_statement__) (Literal 150)))
                  (VariableDefn
                   ((static false) (constexpr false)
-                   (type_ (TypeLiteral std::stringstream)) (name errmsg_stream__)
+                   (type_ (TypeLiteral std::stringstream AoS)) (name errmsg_stream__)
                    (init Uninitialized)))
                  (Expression
                   (FunCall stan::math::stan_print ()
@@ -8815,18 +9290,18 @@
               (Expression (MethodCall (Var out__) write () ((Var gq_real_1d_ar))))
               (Expression (Assign (Var current_statement__) (Literal 46)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var K)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var M)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var N)) (Increment (Var sym3__))
                      (Block
                       ((Expression
@@ -8840,13 +9315,13 @@
               (Expression (MethodCall (Var out__) write () ((Var gq_vec))))
               (Expression (Assign (Var current_statement__) (Literal 48)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                   (Block
                    ((Expression
@@ -8857,22 +9332,22 @@
                         (Parens (BinOp (Var sym1__) Subtract (Literal 1)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 49)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym4__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                         (Block
@@ -8889,13 +9364,13 @@
               (Expression (MethodCall (Var out__) write () ((Var gq_row_vec))))
               (Expression (Assign (Var current_statement__) (Literal 51)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                   (Block
                    ((Expression
@@ -8906,22 +9381,22 @@
                         (Parens (BinOp (Var sym1__) Subtract (Literal 1)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 52)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym4__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                         (Block
@@ -8937,22 +9412,22 @@
                               (Parens (BinOp (Var sym1__) Subtract (Literal 1)))))))))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 53)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym4__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym4__) LEq (Literal 4)) (Increment (Var sym4__))
                         (Block
@@ -8967,13 +9442,13 @@
               (Expression (MethodCall (Var out__) write () ((Var gq_simplex))))
               (Expression (Assign (Var current_statement__) (Literal 55)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                   (Block
                    ((Expression
@@ -8984,22 +9459,22 @@
                         (Parens (BinOp (Var sym1__) Subtract (Literal 1)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 56)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym4__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                         (Block
@@ -9017,18 +9492,18 @@
               (Expression (MethodCall (Var out__) write () ((Var gq_cfcov_33))))
               (Expression (Assign (Var current_statement__) (Literal 59)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var K)) (Increment (Var sym3__))
                      (Block
                       ((Expression
@@ -9041,18 +9516,18 @@
               (Expression (MethodCall (Var out__) write () ((Var indices))))
               (Expression (Assign (Var current_statement__) (Literal 61)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                      (Block
                       ((Expression
@@ -9064,18 +9539,18 @@
                             (FunCall stan::model::index_uni () ((Var sym1__)))))))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 62)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Literal 3)) (Increment (Var sym3__))
                      (Block
                       ((Expression
@@ -9087,18 +9562,18 @@
                             (FunCall stan::model::index_uni () ((Var sym1__)))))))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 63)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                      (Block
                       ((Expression
@@ -9110,18 +9585,18 @@
                             (FunCall stan::model::index_uni () ((Var sym1__)))))))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 64)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Literal 3)) (Increment (Var sym3__))
                      (Block
                       ((Expression
@@ -9133,18 +9608,18 @@
                             (FunCall stan::model::index_uni () ((Var sym1__)))))))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 65)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Literal 3)) (Increment (Var sym3__))
                      (Block
                       ((Expression
@@ -9156,18 +9631,18 @@
                             (FunCall stan::model::index_uni () ((Var sym1__)))))))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 66)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                      (Block
                       ((Expression
@@ -9179,18 +9654,18 @@
                             (FunCall stan::model::index_uni () ((Var sym1__)))))))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 67)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Literal 3)) (Increment (Var sym3__))
                      (Block
                       ((Expression
@@ -9202,13 +9677,13 @@
                             (FunCall stan::model::index_uni () ((Var sym1__)))))))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 68)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                   (Block
                    ((Expression
@@ -9219,13 +9694,13 @@
                         (Parens (BinOp (Var sym1__) Subtract (Literal 1)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 69)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 2)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                   (Block
                    ((Expression
@@ -9234,7 +9709,7 @@
                         (Index (Var idx_res5)
                          (Parens (BinOp (Var sym2__) Subtract (Literal 1))))
                         (Parens (BinOp (Var sym1__) Subtract (Literal 1))))))))))))))
-             ((Const (Ref (TypeLiteral std::exception))) e)
+             ((Const (Ref (TypeLiteral std::exception AoS))) e)
              ((Expression
                (FunCall stan::lang::rethrow_located ()
                 ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -9248,23 +9723,25 @@
           (((Const (Ref (TemplateType VecVar))) params_r__)
            ((Const (Ref (TemplateType VecI))) params_i__)
            ((Ref (TemplateType VecVar)) vars__)
-           ((Pointer (TypeLiteral std::ostream)) "pstream__ = nullptr")))
+           ((Pointer (TypeLiteral std::ostream AoS)) "pstream__ = nullptr")))
          (cv_qualifiers (Const))
          (body
-          (((Using local_scalar_t__ (Double))
+          (((Using local_scalar_t__ ((Double AoS)))
             (VariableDefn
              ((static false) (constexpr false)
-              (type_ (TypeTrait stan::io::deserializer ((TypeLiteral local_scalar_t__))))
+              (type_
+               (TypeTrait stan::io::deserializer ((TypeLiteral local_scalar_t__ AoS))))
               (name in__) (init (Construction ((Var params_r__) (Var params_i__))))))
             (VariableDefn
              ((static false) (constexpr false)
-              (type_ (TypeTrait stan::io::serializer ((TypeLiteral local_scalar_t__))))
+              (type_
+               (TypeTrait stan::io::serializer ((TypeLiteral local_scalar_t__ AoS))))
               (name out__) (init (Construction ((Var vars__))))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ Int) (name current_statement__)
-              (init (Assignment (Literal 0)))))
+             ((static false) (constexpr false) (type_ (Int AoS))
+              (name current_statement__) (init (Assignment (Literal 0)))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+             ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
               (name DUMMY_VAR__)
               (init
                (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
@@ -9272,44 +9749,48 @@
             (Expression (Cast Void (Var DUMMY_VAR__)))
             (TryCatch
              ((VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name p_real) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name p_real)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 1)))
               (Expression
                (Assign (Var p_real)
-                (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__)) ())))
+                (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__ AoS)) ())))
               (Expression (MethodCall (Var out__) write () ((Var p_real))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name p_upper) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name p_upper)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 2)))
               (Expression
                (Assign (Var p_upper)
-                (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__)) ())))
+                (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__ AoS)) ())))
               (Expression
                (MethodCall (Var out__) write_free_lb () ((Var p_real) (Var p_upper))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name p_lower) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name p_lower)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 3)))
               (Expression
                (Assign (Var p_lower)
-                (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__)) ())))
+                (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__ AoS)) ())))
               (Expression
                (MethodCall (Var out__) write_free_ub () ((Var p_upper) (Var p_lower))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                 (name offset_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Literal 5) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 4)))
               (Expression
                (FunCall stan::model::assign ()
                 ((Var offset_multiplier)
-                 (MethodCall (Var in__) read ((StdVector (TypeLiteral local_scalar_t__)))
+                 (MethodCall (Var in__) read
+                  ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)) 
                   ((Literal 5)))
                  (Literal "\"assigning variable offset_multiplier\""))))
               (Expression
@@ -9317,17 +9798,18 @@
                 ((Literal 1) (Literal 2) (Var offset_multiplier))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                 (name no_offset_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Literal 5) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 5)))
               (Expression
                (FunCall stan::model::assign ()
                 ((Var no_offset_multiplier)
-                 (MethodCall (Var in__) read ((StdVector (TypeLiteral local_scalar_t__)))
+                 (MethodCall (Var in__) read
+                  ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)) 
                   ((Literal 5)))
                  (Literal "\"assigning variable no_offset_multiplier\""))))
               (Expression
@@ -9335,17 +9817,18 @@
                 ((Literal 0) (Literal 2) (Var no_offset_multiplier))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                 (name offset_no_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Literal 5) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 6)))
               (Expression
                (FunCall stan::model::assign ()
                 ((Var offset_no_multiplier)
-                 (MethodCall (Var in__) read ((StdVector (TypeLiteral local_scalar_t__)))
+                 (MethodCall (Var in__) read
+                  ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)) 
                   ((Literal 5)))
                  (Literal "\"assigning variable offset_no_multiplier\""))))
               (Expression
@@ -9353,16 +9836,18 @@
                 ((Literal 3) (Literal 1) (Var offset_no_multiplier))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__))) (name p_real_1d_ar)
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+                (name p_real_1d_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Var N) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 7)))
               (Expression
                (FunCall stan::model::assign ()
                 ((Var p_real_1d_ar)
-                 (MethodCall (Var in__) read ((StdVector (TypeLiteral local_scalar_t__)))
+                 (MethodCall (Var in__) read
+                  ((StdVector (TypeLiteral local_scalar_t__ AoS) AoS)) 
                   ((Var N)))
                  (Literal "\"assigning variable p_real_1d_ar\""))))
               (Expression
@@ -9370,31 +9855,35 @@
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
-                 (StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__)))))
+                 (StdVector
+                  (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS) AoS))
                 (name p_real_3d_ar)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__))))
+                   (StdVector
+                    (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
+                    AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (TypeLiteral local_scalar_t__)))
+                    (Constructor
+                     (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                      (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                        ((Var K) (Var DUMMY_VAR__)))))))))))
               (Expression (Assign (Var current_statement__) (Literal 8)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var K)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var M)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var N)) (Increment (Var sym3__))
                      (Block
                       ((Expression (Assign (Var current_statement__) (Literal 8)))
@@ -9406,54 +9895,58 @@
                             (Parens (BinOp (Var sym3__) Subtract (Literal 1))))
                            (Parens (BinOp (Var sym2__) Subtract (Literal 1))))
                           (Parens (BinOp (Var sym1__) Subtract (Literal 1))))
-                         (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__)) ()))))))))))))
+                         (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__ AoS))
+                          ()))))))))))))
               (Expression
                (MethodCall (Var out__) write_free_lb () ((Literal 0) (Var p_real_3d_ar))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                 (name p_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 9)))
               (Expression
                (FunCall stan::model::assign ()
                 ((Var p_vec)
                  (MethodCall (Var in__) read
-                  ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                  ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                   ((Var N)))
                  (Literal "\"assigning variable p_vec\""))))
               (Expression
                (MethodCall (Var out__) write_free_lb () ((Literal 0) (Var p_vec))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                 (name p_1d_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (Expression (Assign (Var current_statement__) (Literal 10)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                   (Block
                    ((Expression (Assign (Var current_statement__) (Literal 10)))
                     (Expression
                      (FunCall stan::model::assign ()
                       ((Var p_1d_vec)
-                       (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__)) ())
+                       (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__ AoS))
+                        ())
                        (Literal "\"assigning variable p_1d_vec\"")
                        (FunCall stan::model::index_uni () ((Var sym2__)))
                        (FunCall stan::model::index_uni () ((Var sym1__))))))))))))
@@ -9463,43 +9956,50 @@
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name p_3d_vec)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 11)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym4__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                         (Block
@@ -9507,8 +10007,8 @@
                           (Expression
                            (FunCall stan::model::assign ()
                             ((Var p_3d_vec)
-                             (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__))
-                              ())
+                             (MethodCall (Var in__) read
+                              ((TypeLiteral local_scalar_t__ AoS)) ())
                              (Literal "\"assigning variable p_3d_vec\"")
                              (FunCall stan::model::index_uni () ((Var sym4__)))
                              (FunCall stan::model::index_uni () ((Var sym3__)))
@@ -9517,48 +10017,51 @@
               (Expression (MethodCall (Var out__) write () ((Var p_3d_vec))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS))
                 (name p_row_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 12)))
               (Expression
                (FunCall stan::model::assign ()
                 ((Var p_row_vec)
                  (MethodCall (Var in__) read
-                  ((Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)) 
+                  ((Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)) 
                   ((Var N)))
                  (Literal "\"assigning variable p_row_vec\""))))
               (Expression (MethodCall (Var out__) write () ((Var p_row_vec))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS))
                 (name p_1d_row_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (Expression (Assign (Var current_statement__) (Literal 13)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                   (Block
                    ((Expression (Assign (Var current_statement__) (Literal 13)))
                     (Expression
                      (FunCall stan::model::assign ()
                       ((Var p_1d_row_vec)
-                       (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__)) ())
+                       (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__ AoS))
+                        ())
                        (Literal "\"assigning variable p_1d_row_vec\"")
                        (FunCall stan::model::index_uni () ((Var sym2__)))
                        (FunCall stan::model::index_uni () ((Var sym1__))))))))))))
@@ -9568,43 +10071,50 @@
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name p_3d_row_vec)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 14)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym4__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                         (Block
@@ -9612,8 +10122,8 @@
                           (Expression
                            (FunCall stan::model::assign ()
                             ((Var p_3d_row_vec)
-                             (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__))
-                              ())
+                             (MethodCall (Var in__) read
+                              ((TypeLiteral local_scalar_t__ AoS)) ())
                              (Literal "\"assigning variable p_3d_row_vec\"")
                              (FunCall stan::model::index_uni () ((Var sym4__)))
                              (FunCall stan::model::index_uni () ((Var sym3__)))
@@ -9622,18 +10132,18 @@
               (Expression (MethodCall (Var out__) write () ((Var p_3d_row_vec))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name p_mat)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 5) (Literal 4) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 15)))
               (Expression
                (FunCall stan::model::assign ()
                 ((Var p_mat)
                  (MethodCall (Var in__) read
-                  ((Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                  ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                   ((Literal 5) (Literal 4)))
                  (Literal "\"assigning variable p_mat\""))))
               (Expression (MethodCall (Var out__) write () ((Var p_mat))))
@@ -9641,37 +10151,41 @@
                ((static false) (constexpr false)
                 (type_
                  (StdVector
-                  (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))))
+                  (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                  AoS))
                 (name p_ar_mat)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                    AoS)
                    ((Literal 4)
                     (Constructor
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
+                      AoS)
                      ((Literal 5)
-                      (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
-                       Constant () ((Literal 2) (Literal 3) (Var DUMMY_VAR__)))))))))))
+                      (StaticMethodCall
+                       (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) Constant ()
+                       ((Literal 2) (Literal 3) (Var DUMMY_VAR__)))))))))))
               (Expression (Assign (Var current_statement__) (Literal 16)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym4__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym4__) LEq (Literal 4)) (Increment (Var sym4__))
                         (Block
@@ -9679,8 +10193,8 @@
                           (Expression
                            (FunCall stan::model::assign ()
                             ((Var p_ar_mat)
-                             (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__))
-                              ())
+                             (MethodCall (Var in__) read
+                              ((TypeLiteral local_scalar_t__ AoS)) ())
                              (Literal "\"assigning variable p_ar_mat\"")
                              (FunCall stan::model::index_uni () ((Var sym4__)))
                              (FunCall stan::model::index_uni () ((Var sym3__)))
@@ -9691,49 +10205,52 @@
                 ((Literal 0) (Literal 1) (Var p_ar_mat))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS))
                 (name p_simplex)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 17)))
               (Expression
                (FunCall stan::model::assign ()
                 ((Var p_simplex)
                  (MethodCall (Var in__) read
-                  ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                  ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                   ((Var N)))
                  (Literal "\"assigning variable p_simplex\""))))
               (Expression
                (MethodCall (Var out__) write_free_simplex () ((Var p_simplex))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                 (name p_1d_simplex)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (Expression (Assign (Var current_statement__) (Literal 18)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                   (Block
                    ((Expression (Assign (Var current_statement__) (Literal 18)))
                     (Expression
                      (FunCall stan::model::assign ()
                       ((Var p_1d_simplex)
-                       (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__)) ())
+                       (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__ AoS))
+                        ())
                        (Literal "\"assigning variable p_1d_simplex\"")
                        (FunCall stan::model::index_uni () ((Var sym2__)))
                        (FunCall stan::model::index_uni () ((Var sym1__))))))))))))
@@ -9744,43 +10261,50 @@
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name p_3d_simplex)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (Expression (Assign (Var current_statement__) (Literal 19)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                      (Block
                       ((For
-                        ((static false) (constexpr false) (type_ Int) 
+                        ((static false) (constexpr false) (type_ (Int AoS)) 
                          (name sym4__) (init (Assignment (Literal 1))))
                         (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                         (Block
@@ -9788,8 +10312,8 @@
                           (Expression
                            (FunCall stan::model::assign ()
                             ((Var p_3d_simplex)
-                             (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__))
-                              ())
+                             (MethodCall (Var in__) read
+                              ((TypeLiteral local_scalar_t__ AoS)) ())
                              (Literal "\"assigning variable p_3d_simplex\"")
                              (FunCall stan::model::index_uni () ((Var sym4__)))
                              (FunCall stan::model::index_uni () ((Var sym3__)))
@@ -9799,18 +10323,18 @@
                (MethodCall (Var out__) write_free_simplex () ((Var p_3d_simplex))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name p_cfcov_54)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 5) (Literal 4) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 20)))
               (Expression
                (FunCall stan::model::assign ()
                 ((Var p_cfcov_54)
                  (MethodCall (Var in__) read
-                  ((Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                  ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                   ((Literal 5) (Literal 4)))
                  (Literal "\"assigning variable p_cfcov_54\""))))
               (Expression
@@ -9818,18 +10342,18 @@
                 ((Var p_cfcov_54))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name p_cfcov_33)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 21)))
               (Expression
                (FunCall stan::model::assign ()
                 ((Var p_cfcov_33)
                  (MethodCall (Var in__) read
-                  ((Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                  ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                   ((Literal 3) (Literal 3)))
                  (Literal "\"assigning variable p_cfcov_33\""))))
               (Expression
@@ -9837,37 +10361,39 @@
                 ((Var p_cfcov_33))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS))
                 (name p_cfcov_33_ar)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
                    ((Var K)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
-                     Constant () ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) Constant ()
+                     ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))))
               (Expression (Assign (Var current_statement__) (Literal 22)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name sym1__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                 (init (Assignment (Literal 1))))
                (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                (Block
                 ((For
-                  ((static false) (constexpr false) (type_ Int) (name sym2__)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name sym2__) (init (Assignment (Literal 1))))
                   (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                   (Block
                    ((For
-                     ((static false) (constexpr false) (type_ Int) (name sym3__)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name sym3__) (init (Assignment (Literal 1))))
                      (BinOp (Var sym3__) LEq (Var K)) (Increment (Var sym3__))
                      (Block
                       ((Expression (Assign (Var current_statement__) (Literal 22)))
                        (Expression
                         (FunCall stan::model::assign ()
                          ((Var p_cfcov_33_ar)
-                          (MethodCall (Var in__) read ((TypeLiteral local_scalar_t__))
-                           ())
+                          (MethodCall (Var in__) read
+                           ((TypeLiteral local_scalar_t__ AoS)) ())
                           (Literal "\"assigning variable p_cfcov_33_ar\"")
                           (FunCall stan::model::index_uni () ((Var sym3__)))
                           (FunCall stan::model::index_uni () ((Var sym2__)))
@@ -9877,39 +10403,39 @@
                 ((Var p_cfcov_33_ar))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                 (name x_p)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Literal 2) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 23)))
               (Expression
                (FunCall stan::model::assign ()
                 ((Var x_p)
                  (MethodCall (Var in__) read
-                  ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                  ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                   ((Literal 2)))
                  (Literal "\"assigning variable x_p\""))))
               (Expression (MethodCall (Var out__) write () ((Var x_p))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                 (name y_p)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Literal 2) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 24)))
               (Expression
                (FunCall stan::model::assign ()
                 ((Var y_p)
                  (MethodCall (Var in__) read
-                  ((Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                  ((Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                   ((Literal 2)))
                  (Literal "\"assigning variable y_p\""))))
               (Expression (MethodCall (Var out__) write () ((Var y_p)))))
-             ((Const (Ref (TypeLiteral std::exception))) e)
+             ((Const (Ref (TypeLiteral std::exception AoS))) e)
              ((Expression
                (FunCall stan::lang::rethrow_located ()
                 ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -9918,21 +10444,22 @@
           ((((Typename VecVar) (Require stan::require_vector_t (VecVar)))) true))
          (inline true) (return_type Void) (name transform_inits_impl)
          (args
-          (((Const (Ref (TypeLiteral stan::io::var_context))) context__)
+          (((Const (Ref (TypeLiteral stan::io::var_context AoS))) context__)
            ((Ref (TemplateType VecVar)) vars__)
-           ((Pointer (TypeLiteral std::ostream)) "pstream__ = nullptr")))
+           ((Pointer (TypeLiteral std::ostream AoS)) "pstream__ = nullptr")))
          (cv_qualifiers (Const))
          (body
-          (((Using local_scalar_t__ (Double))
+          (((Using local_scalar_t__ ((Double AoS)))
             (VariableDefn
              ((static false) (constexpr false)
-              (type_ (TypeTrait stan::io::serializer ((TypeLiteral local_scalar_t__))))
+              (type_
+               (TypeTrait stan::io::serializer ((TypeLiteral local_scalar_t__ AoS))))
               (name out__) (init (Construction ((Var vars__))))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ Int) (name current_statement__)
-              (init (Assignment (Literal 0)))))
+             ((static false) (constexpr false) (type_ (Int AoS))
+              (name current_statement__) (init (Assignment (Literal 0)))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+             ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
               (name DUMMY_VAR__)
               (init
                (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
@@ -9944,195 +10471,196 @@
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_real\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t)) ()))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ()))))
               (Expression (Assign (Var current_statement__) (Literal 2)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_upper\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t)) ()))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ()))))
               (Expression (Assign (Var current_statement__) (Literal 3)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_lower\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t)) ()))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ()))))
               (Expression (Assign (Var current_statement__) (Literal 4)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"")
                  (Literal "\"offset_multiplier\"") (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5))))))))
               (Expression (Assign (Var current_statement__) (Literal 5)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"")
                  (Literal "\"no_offset_multiplier\"") (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5))))))))
               (Expression (Assign (Var current_statement__) (Literal 6)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"")
                  (Literal "\"offset_no_multiplier\"") (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5))))))))
               (Expression (Assign (Var current_statement__) (Literal 7)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_real_1d_ar\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
               (Expression (Assign (Var current_statement__) (Literal 8)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_real_3d_ar\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var K))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K))))))))
               (Expression (Assign (Var current_statement__) (Literal 9)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_vec\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
               (Expression (Assign (Var current_statement__) (Literal 10)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_1d_vec\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
               (Expression (Assign (Var current_statement__) (Literal 11)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_3d_vec\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
               (Expression (Assign (Var current_statement__) (Literal 12)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_row_vec\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
               (Expression (Assign (Var current_statement__) (Literal 13)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_1d_row_vec\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
               (Expression (Assign (Var current_statement__) (Literal 14)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_3d_row_vec\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
               (Expression (Assign (Var current_statement__) (Literal 15)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_mat\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4))))))))
               (Expression (Assign (Var current_statement__) (Literal 16)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_ar_mat\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3))))))))
               (Expression (Assign (Var current_statement__) (Literal 17)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_simplex\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
               (Expression (Assign (Var current_statement__) (Literal 18)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_1d_simplex\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
               (Expression (Assign (Var current_statement__) (Literal 19)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_3d_simplex\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
               (Expression (Assign (Var current_statement__) (Literal 20)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_cfcov_54\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4))))))))
               (Expression (Assign (Var current_statement__) (Literal 21)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_cfcov_33\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3))))))))
               (Expression (Assign (Var current_statement__) (Literal 22)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"p_cfcov_33_ar\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                   (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                   (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3))))))))
               (Expression (Assign (Var current_statement__) (Literal 23)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"x_p\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 2))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2))))))))
               (Expression (Assign (Var current_statement__) (Literal 24)))
               (Expression
                (MethodCall (Var context__) validate_dims ()
                 ((Literal "\"parameter initialization\"") (Literal "\"y_p\"")
                  (Literal "\"double\"")
-                 (InitializerExpr (StdVector (TypeLiteral size_t))
-                  ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 2))))))))
+                 (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                  ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2))))))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ Int) (name pos__)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name pos__)
                 (init (Assignment (FunCall std::numeric_limits<int>::min () ())))))
               (Expression (Assign (Var pos__) (Literal 1)))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name p_real) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name p_real)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 1)))
               (Expression
                (Assign (Var p_real)
@@ -10140,8 +10668,9 @@
                  (Parens (BinOp (Literal 1) Subtract (Literal 1))))))
               (Expression (MethodCall (Var out__) write () ((Var p_real))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name p_upper) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name p_upper)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 2)))
               (Expression
                (Assign (Var p_upper)
@@ -10150,8 +10679,9 @@
               (Expression
                (MethodCall (Var out__) write_free_lb () ((Var p_real) (Var p_upper))))
               (VariableDefn
-               ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
-                (name p_lower) (init (Assignment (Var DUMMY_VAR__)))))
+               ((static false) (constexpr false)
+                (type_ (TypeLiteral local_scalar_t__ AoS)) (name p_lower)
+                (init (Assignment (Var DUMMY_VAR__)))))
               (Expression (Assign (Var current_statement__) (Literal 3)))
               (Expression
                (Assign (Var p_lower)
@@ -10161,11 +10691,11 @@
                (MethodCall (Var out__) write_free_ub () ((Var p_upper) (Var p_lower))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                 (name offset_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Literal 5) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 4)))
               (Expression
@@ -10177,11 +10707,11 @@
                 ((Literal 1) (Literal 2) (Var offset_multiplier))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                 (name no_offset_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Literal 5) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 5)))
               (Expression
@@ -10193,11 +10723,11 @@
                 ((Literal 0) (Literal 2) (Var no_offset_multiplier))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                 (name offset_no_multiplier)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Literal 5) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 6)))
               (Expression
@@ -10209,10 +10739,11 @@
                 ((Literal 3) (Literal 1) (Var offset_no_multiplier))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (TypeLiteral local_scalar_t__))) (name p_real_1d_ar)
+                (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+                (name p_real_1d_ar)
                 (init
                  (Assignment
-                  (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                  (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                    ((Var N) (Var DUMMY_VAR__)))))))
               (Expression (Assign (Var current_statement__) (Literal 7)))
               (Expression
@@ -10223,21 +10754,25 @@
               (VariableDefn
                ((static false) (constexpr false)
                 (type_
-                 (StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__)))))
+                 (StdVector
+                  (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS) AoS))
                 (name p_real_3d_ar)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (StdVector (StdVector (TypeLiteral local_scalar_t__))))
+                   (StdVector
+                    (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
+                    AoS)
                    ((Var N)
-                    (Constructor (StdVector (StdVector (TypeLiteral local_scalar_t__)))
+                    (Constructor
+                     (StdVector (StdVector (TypeLiteral local_scalar_t__ AoS) AoS) AoS)
                      ((Var M)
-                      (Constructor (StdVector (TypeLiteral local_scalar_t__))
+                      (Constructor (StdVector (TypeLiteral local_scalar_t__ AoS) AoS)
                        ((Var K) (Var DUMMY_VAR__)))))))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_real_3d_ar_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 8)))
                 (Expression
@@ -10245,17 +10780,17 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_real_3d_ar\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Var K)) (Increment (Var sym1__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym2__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym2__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym2__) LEq (Var M)) (Increment (Var sym2__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym3__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym3__) LEq (Var N)) (Increment (Var sym3__))
                        (Block
@@ -10275,16 +10810,16 @@
                (MethodCall (Var out__) write_free_lb () ((Literal 0) (Var p_real_3d_ar))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                 (name p_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__))) 
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_vec_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 9)))
                 (Expression
@@ -10292,8 +10827,8 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_vec\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                  (Block
                   ((Expression
@@ -10309,19 +10844,21 @@
                (MethodCall (Var out__) write_free_lb () ((Literal 0) (Var p_vec))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                 (name p_1d_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_1d_vec_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 10)))
                 (Expression
@@ -10329,13 +10866,13 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_1d_vec\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym2__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym2__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                     (Block
                      ((Expression
@@ -10354,29 +10891,36 @@
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name p_3d_vec)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_3d_vec_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 11)))
                 (Expression
@@ -10384,22 +10928,22 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_3d_vec\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym2__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym2__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym3__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                        (Block
                         ((For
-                          ((static false) (constexpr false) (type_ Int) 
+                          ((static false) (constexpr false) (type_ (Int AoS))
                            (name sym4__) (init (Assignment (Literal 1))))
                           (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                           (Block
@@ -10419,16 +10963,16 @@
               (Expression (MethodCall (Var out__) write () ((Var p_3d_vec))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS))
                 (name p_row_vec)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_row_vec_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 12)))
                 (Expression
@@ -10436,8 +10980,8 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_row_vec\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                  (Block
                   ((Expression
@@ -10452,19 +10996,21 @@
               (Expression (MethodCall (Var out__) write () ((Var p_row_vec))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS))
                 (name p_1d_row_vec)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_1d_row_vec_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 13)))
                 (Expression
@@ -10472,13 +11018,13 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_1d_row_vec\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym2__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym2__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                     (Block
                      ((Expression
@@ -10497,29 +11043,36 @@
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name p_3d_row_vec)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) 1 -1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) 1 -1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_3d_row_vec_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 14)))
                 (Expression
@@ -10527,22 +11080,22 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_3d_row_vec\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym2__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym2__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym3__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                        (Block
                         ((For
-                          ((static false) (constexpr false) (type_ Int) 
+                          ((static false) (constexpr false) (type_ (Int AoS))
                            (name sym4__) (init (Assignment (Literal 1))))
                           (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                           (Block
@@ -10562,16 +11115,16 @@
               (Expression (MethodCall (Var out__) write () ((Var p_3d_row_vec))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name p_mat)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 5) (Literal 4) (Var DUMMY_VAR__)))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__))) 
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_mat_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 15)))
                 (Expression
@@ -10579,13 +11132,13 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_mat\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym2__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym2__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym2__) LEq (Literal 5)) (Increment (Var sym2__))
                     (Block
                      ((Expression
@@ -10603,23 +11156,27 @@
                ((static false) (constexpr false)
                 (type_
                  (StdVector
-                  (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))))
+                  (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                  AoS))
                 (name p_ar_mat)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
-                    (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                    (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
+                    AoS)
                    ((Literal 4)
                     (Constructor
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
+                      AoS)
                      ((Literal 5)
-                      (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
-                       Constant () ((Literal 2) (Literal 3) (Var DUMMY_VAR__)))))))))))
+                      (StaticMethodCall
+                       (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) Constant ()
+                       ((Literal 2) (Literal 3) (Var DUMMY_VAR__)))))))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_ar_mat_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 16)))
                 (Expression
@@ -10627,22 +11184,22 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_ar_mat\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym2__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym2__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym3__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                        (Block
                         ((For
-                          ((static false) (constexpr false) (type_ Int) 
+                          ((static false) (constexpr false) (type_ (Int AoS))
                            (name sym4__) (init (Assignment (Literal 1))))
                           (BinOp (Var sym4__) LEq (Literal 4)) (Increment (Var sym4__))
                           (Block
@@ -10664,16 +11221,16 @@
                 ((Literal 0) (Literal 1) (Var p_ar_mat))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS))
                 (name p_simplex)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Var N) (Var DUMMY_VAR__)))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_simplex_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 17)))
                 (Expression
@@ -10681,8 +11238,8 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_simplex\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                  (Block
                   ((Expression
@@ -10698,19 +11255,21 @@
                (MethodCall (Var out__) write_free_simplex () ((Var p_simplex))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS))
                 (name p_1d_simplex)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
                    ((Var N)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
-                     Constant () ((Var N) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
+                     ((Var N) (Var DUMMY_VAR__)))))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_1d_simplex_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 18)))
                 (Expression
@@ -10718,13 +11277,13 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_1d_simplex\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym2__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym2__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                     (Block
                      ((Expression
@@ -10744,29 +11303,36 @@
                 (type_
                  (StdVector
                   (StdVector
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                   AoS)
+                  AoS))
                 (name p_3d_simplex)
                 (init
                  (Assignment
                   (Constructor
                    (StdVector
                     (StdVector
-                     (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))))
+                     (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) AoS)
+                     AoS)
+                    AoS)
                    ((Var N)
                     (Constructor
                      (StdVector
-                      (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)))
+                      (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                       AoS)
+                      AoS)
                      ((Var M)
                       (Constructor
-                       (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS))
+                       (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
+                        AoS)
                        ((Var K)
                         (StaticMethodCall
-                         (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS) Constant ()
+                         (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS) Constant ()
                          ((Var N) (Var DUMMY_VAR__)))))))))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_3d_simplex_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 19)))
                 (Expression
@@ -10774,22 +11340,22 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_3d_simplex\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym2__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym2__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym3__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                        (Block
                         ((For
-                          ((static false) (constexpr false) (type_ Int) 
+                          ((static false) (constexpr false) (type_ (Int AoS))
                            (name sym4__) (init (Assignment (Literal 1))))
                           (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                           (Block
@@ -10810,16 +11376,16 @@
                (MethodCall (Var out__) write_free_simplex () ((Var p_3d_simplex))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name p_cfcov_54)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 5) (Literal 4) (Var DUMMY_VAR__)))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_cfcov_54_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 20)))
                 (Expression
@@ -10827,13 +11393,13 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_cfcov_54\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym2__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym2__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym2__) LEq (Literal 5)) (Increment (Var sym2__))
                     (Block
                      ((Expression
@@ -10851,16 +11417,16 @@
                 ((Var p_cfcov_54))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS))
                 (name p_cfcov_33)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS)
                    Constant () ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_cfcov_33_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 21)))
                 (Expression
@@ -10868,13 +11434,13 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_cfcov_33\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym2__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym2__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                     (Block
                      ((Expression
@@ -10892,19 +11458,21 @@
                 ((Var p_cfcov_33))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)))
+                (type_
+                 (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS))
                 (name p_cfcov_33_ar)
                 (init
                  (Assignment
                   (Constructor
-                   (StdVector (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS))
+                   (StdVector (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) AoS)
                    ((Var K)
-                    (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 -1 AoS)
-                     Constant () ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))))
+                    (StaticMethodCall
+                     (Matrix (TypeLiteral local_scalar_t__ AoS) -1 -1 AoS) Constant ()
+                     ((Literal 3) (Literal 3) (Var DUMMY_VAR__)))))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__)))
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name p_cfcov_33_ar_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 22)))
                 (Expression
@@ -10912,17 +11480,17 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"p_cfcov_33_ar\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym2__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym2__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym3__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym3__) LEq (Var K)) (Increment (Var sym3__))
                        (Block
@@ -10943,16 +11511,16 @@
                 ((Var p_cfcov_33_ar))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                 (name x_p)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Literal 2) (Var DUMMY_VAR__)))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__))) 
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name x_p_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 23)))
                 (Expression
@@ -10960,8 +11528,8 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"x_p\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Literal 2)) (Increment (Var sym1__))
                  (Block
                   ((Expression
@@ -10976,16 +11544,16 @@
               (Expression (MethodCall (Var out__) write () ((Var x_p))))
               (VariableDefn
                ((static false) (constexpr false)
-                (type_ (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)) 
+                (type_ (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)) 
                 (name y_p)
                 (init
                  (Assignment
-                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__) -1 1 AoS)
+                  (StaticMethodCall (Matrix (TypeLiteral local_scalar_t__ AoS) -1 1 AoS)
                    Constant () ((Literal 2) (Var DUMMY_VAR__)))))))
               (Block
                ((VariableDefn
                  ((static false) (constexpr false)
-                  (type_ (StdVector (TypeLiteral local_scalar_t__))) 
+                  (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                   (name y_p_flat__) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 24)))
                 (Expression
@@ -10993,8 +11561,8 @@
                   (MethodCall (Var context__) vals_r () ((Literal "\"y_p\"")))))
                 (Expression (Assign (Var pos__) (Literal 1)))
                 (For
-                 ((static false) (constexpr false) (type_ Int) (name sym1__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym1__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym1__) LEq (Literal 2)) (Increment (Var sym1__))
                  (Block
                   ((Expression
@@ -11007,7 +11575,7 @@
                    (Expression
                     (Assign (Var pos__) (Parens (BinOp (Var pos__) Add (Literal 1))))))))))
               (Expression (MethodCall (Var out__) write () ((Var y_p)))))
-             ((Const (Ref (TypeLiteral std::exception))) e)
+             ((Const (Ref (TypeLiteral std::exception AoS))) e)
              ((Expression
                (FunCall stan::lang::rethrow_located ()
                 ((Var e) (Index (Var locations_array__) (Var current_statement__))))))))))))
@@ -11015,14 +11583,14 @@
         ((templates_init ((()) false)) (inline true) (return_type Void)
          (name get_param_names)
          (args
-          (((Ref (StdVector (TypeLiteral std::string))) names__)
-           ((Const (TypeLiteral bool)) "emit_transformed_parameters__ = true")
-           ((Const (TypeLiteral bool)) "emit_generated_quantities__ = true")))
+          (((Ref (StdVector (TypeLiteral std::string AoS) AoS)) names__)
+           ((Const (TypeLiteral bool AoS)) "emit_transformed_parameters__ = true")
+           ((Const (TypeLiteral bool AoS)) "emit_generated_quantities__ = true")))
          (cv_qualifiers (Const))
          (body
           (((Expression
              (Assign (Var names__)
-              (InitializerExpr (StdVector (TypeLiteral std::string))
+              (InitializerExpr (StdVector (TypeLiteral std::string AoS) AoS)
                ((Literal "\"p_real\"") (Literal "\"p_upper\"") (Literal "\"p_lower\"")
                 (Literal "\"offset_multiplier\"") (Literal "\"no_offset_multiplier\"")
                 (Literal "\"offset_no_multiplier\"") (Literal "\"p_real_1d_ar\"")
@@ -11038,7 +11606,8 @@
              (Block
               ((VariableDefn
                 ((static false) (constexpr false)
-                 (type_ (StdVector (TypeLiteral std::string))) (name temp)
+                 (type_ (StdVector (TypeLiteral std::string AoS) AoS)) 
+                 (name temp)
                  (init
                   (InitializerList
                    ((Literal "\"tp_real_1d_ar\"") (Literal "\"tp_real_3d_ar\"")
@@ -11063,7 +11632,8 @@
              (Block
               ((VariableDefn
                 ((static false) (constexpr false)
-                 (type_ (StdVector (TypeLiteral std::string))) (name temp)
+                 (type_ (StdVector (TypeLiteral std::string AoS) AoS)) 
+                 (name temp)
                  (init
                   (InitializerList
                    ((Literal "\"gq_r1\"") (Literal "\"gq_r2\"")
@@ -11093,146 +11663,146 @@
         ((templates_init ((()) false)) (inline true) (return_type Void) 
          (name get_dims)
          (args
-          (((Ref (StdVector (StdVector (TypeLiteral size_t)))) dimss__)
-           ((Const (TypeLiteral bool)) "emit_transformed_parameters__ = true")
-           ((Const (TypeLiteral bool)) "emit_generated_quantities__ = true")))
+          (((Ref (StdVector (StdVector (TypeLiteral size_t AoS) AoS) AoS)) dimss__)
+           ((Const (TypeLiteral bool AoS)) "emit_transformed_parameters__ = true")
+           ((Const (TypeLiteral bool AoS)) "emit_generated_quantities__ = true")))
          (cv_qualifiers (Const))
          (body
           (((Expression
              (Assign (Var dimss__)
-              (InitializerExpr (StdVector (StdVector (TypeLiteral size_t)))
-               ((InitializerExpr (StdVector (TypeLiteral size_t)) ())
-                (InitializerExpr (StdVector (TypeLiteral size_t)) ())
-                (InitializerExpr (StdVector (TypeLiteral size_t)) ())
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                  (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))))
-                (InitializerExpr (StdVector (TypeLiteral size_t))
-                 ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))))))))
+              (InitializerExpr (StdVector (StdVector (TypeLiteral size_t AoS) AoS) AoS)
+               ((InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ())
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ())
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ())
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                  (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))))
+                (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                 ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))))))))
             (IfElse (Var emit_transformed_parameters__)
              (Block
               ((VariableDefn
                 ((static false) (constexpr false)
-                 (type_ (StdVector (StdVector (TypeLiteral size_t)))) 
+                 (type_ (StdVector (StdVector (TypeLiteral size_t AoS) AoS) AoS))
                  (name temp)
                  (init
                   (InitializerList
-                   ((InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t)) ()))))))
+                   ((InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ()))))))
                (Expression
                 (MethodCall (Var dimss__) reserve ()
                  ((BinOp (MethodCall (Var dimss__) size () ()) Add
@@ -11246,99 +11816,99 @@
              (Block
               ((VariableDefn
                 ((static false) (constexpr false)
-                 (type_ (StdVector (StdVector (TypeLiteral size_t)))) 
+                 (type_ (StdVector (StdVector (TypeLiteral size_t AoS) AoS) AoS))
                  (name temp)
                  (init
                   (InitializerList
-                   ((InitializerExpr (StdVector (TypeLiteral size_t)) ())
-                    (InitializerExpr (StdVector (TypeLiteral size_t)) ())
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Var N)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))))
-                    (InitializerExpr (StdVector (TypeLiteral size_t))
-                     ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                      (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2))))))))))
+                   ((InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ())
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ())
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))))
+                    (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+                     ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                      (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2))))))))))
                (Expression
                 (MethodCall (Var dimss__) reserve ()
                  ((BinOp (MethodCall (Var dimss__) size () ()) Add
@@ -11352,81 +11922,81 @@
         ((templates_init ((()) false)) (inline true) (return_type Void)
          (name constrained_param_names)
          (args
-          (((Ref (StdVector (TypeLiteral std::string))) param_names__)
-           ((TypeLiteral bool) "emit_transformed_parameters__ = true")
-           ((TypeLiteral bool) "emit_generated_quantities__ = true")))
+          (((Ref (StdVector (TypeLiteral std::string AoS) AoS)) param_names__)
+           ((TypeLiteral bool AoS) "emit_transformed_parameters__ = true")
+           ((TypeLiteral bool AoS) "emit_generated_quantities__ = true")))
          (cv_qualifiers (Const Final))
          (body
           (((Expression
              (MethodCall (Var param_names__) emplace_back ()
-              ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+              ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                 (Literal "\"p_real\"")))))
             (Expression
              (MethodCall (Var param_names__) emplace_back ()
-              ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+              ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                 (Literal "\"p_upper\"")))))
             (Expression
              (MethodCall (Var param_names__) emplace_back ()
-              ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+              ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                 (Literal "\"p_lower\"")))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 5)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"offset_multiplier\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 5)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"no_offset_multiplier\"") Add (Literal '.'))
                     Add (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 5)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"offset_no_multiplier\"") Add (Literal '.'))
                     Add (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"p_real_1d_ar\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var K)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var M)) (Increment (Var sym2__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym3__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym3__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym3__) LEq (Var N)) (Increment (Var sym3__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp
@@ -11439,28 +12009,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"p_vec\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp
                        (BinOp
                         (BinOp (BinOp (Literal "\"p_1d_vec\"") Add (Literal '.')) Add
@@ -11468,28 +12038,28 @@
                         Add (Literal '.'))
                        Add (FunCall std::to_string () ((Var sym1__))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym3__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym3__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym4__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym4__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -11506,28 +12076,28 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"p_row_vec\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp
                        (BinOp
                         (BinOp (BinOp (Literal "\"p_1d_row_vec\"") Add (Literal '.')) Add
@@ -11535,28 +12105,28 @@
                         Add (Literal '.'))
                        Add (FunCall std::to_string () ((Var sym1__))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym3__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym3__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym4__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym4__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -11573,18 +12143,18 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Literal 5)) (Increment (Var sym2__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp
                        (BinOp
                         (BinOp (BinOp (Literal "\"p_mat\"") Add (Literal '.')) Add
@@ -11592,28 +12162,28 @@
                         Add (Literal '.'))
                        Add (FunCall std::to_string () ((Var sym1__))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym3__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym3__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym4__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym4__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym4__) LEq (Literal 4)) (Increment (Var sym4__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -11630,28 +12200,28 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"p_simplex\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp
                        (BinOp
                         (BinOp (BinOp (Literal "\"p_1d_simplex\"") Add (Literal '.')) Add
@@ -11659,28 +12229,28 @@
                         Add (Literal '.'))
                        Add (FunCall std::to_string () ((Var sym1__))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym3__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym3__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym4__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym4__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -11697,18 +12267,18 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Literal 5)) (Increment (Var sym2__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp
                        (BinOp
                         (BinOp (BinOp (Literal "\"p_cfcov_54\"") Add (Literal '.')) Add
@@ -11716,18 +12286,18 @@
                         Add (Literal '.'))
                        Add (FunCall std::to_string () ((Var sym1__))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp
                        (BinOp
                         (BinOp (BinOp (Literal "\"p_cfcov_33\"") Add (Literal '.')) Add
@@ -11735,23 +12305,23 @@
                         Add (Literal '.'))
                        Add (FunCall std::to_string () ((Var sym1__))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym3__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym3__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym3__) LEq (Var K)) (Increment (Var sym3__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp
@@ -11764,55 +12334,55 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 2)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"x_p\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 2)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"y_p\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (IfElse (Var emit_transformed_parameters__)
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"tp_real_1d_ar\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var K)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var M)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var N)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -11825,28 +12395,28 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"tp_vec\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"tp_1d_vec\"") Add (Literal '.')) Add
@@ -11854,28 +12424,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -11892,28 +12462,28 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"tp_row_vec\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"tp_1d_row_vec\"") Add (Literal '.'))
@@ -11921,28 +12491,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -11960,18 +12530,18 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 5)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"tp_mat\"") Add (Literal '.')) Add
@@ -11979,28 +12549,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Literal 4)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -12017,28 +12587,28 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"tp_simplex\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"tp_1d_simplex\"") Add (Literal '.'))
@@ -12046,28 +12616,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -12085,18 +12655,18 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 5)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"tp_cfcov_54\"") Add (Literal '.'))
@@ -12104,18 +12674,18 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"tp_cfcov_33\"") Add (Literal '.'))
@@ -12123,23 +12693,23 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var K)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -12152,58 +12722,58 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 2)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"theta_p\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (Literal "\"tp_real\"")))))))
              ())
             (IfElse (Var emit_generated_quantities__)
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (Literal "\"gq_r1\"")))))
                (Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (Literal "\"gq_r2\"")))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"gq_real_1d_ar\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var K)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var M)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var N)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -12216,28 +12786,28 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"gq_vec\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"gq_1d_vec\"") Add (Literal '.')) Add
@@ -12245,28 +12815,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -12283,28 +12853,28 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"gq_row_vec\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"gq_1d_row_vec\"") Add (Literal '.'))
@@ -12312,28 +12882,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -12351,28 +12921,28 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Literal 4)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -12389,28 +12959,28 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"gq_simplex\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"gq_1d_simplex\"") Add (Literal '.'))
@@ -12418,28 +12988,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -12457,18 +13027,18 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 5)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"gq_cfcov_54\"") Add (Literal '.'))
@@ -12476,18 +13046,18 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"gq_cfcov_33\"") Add (Literal '.'))
@@ -12495,23 +13065,23 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var K)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -12524,33 +13094,33 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"indices\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -12563,23 +13133,23 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 3)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -12591,23 +13161,23 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -12619,23 +13189,23 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 3)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -12647,23 +13217,23 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 3)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -12676,23 +13246,23 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -12705,23 +13275,23 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 3)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -12734,18 +13304,18 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"idx_res4\"") Add (Literal '.')) Add
@@ -12753,18 +13323,18 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 2)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"idx_res5\"") Add (Literal '.')) Add
@@ -12776,81 +13346,81 @@
         ((templates_init ((()) false)) (inline true) (return_type Void)
          (name unconstrained_param_names)
          (args
-          (((Ref (StdVector (TypeLiteral std::string))) param_names__)
-           ((TypeLiteral bool) "emit_transformed_parameters__ = true")
-           ((TypeLiteral bool) "emit_generated_quantities__ = true")))
+          (((Ref (StdVector (TypeLiteral std::string AoS) AoS)) param_names__)
+           ((TypeLiteral bool AoS) "emit_transformed_parameters__ = true")
+           ((TypeLiteral bool AoS) "emit_generated_quantities__ = true")))
          (cv_qualifiers (Const Final))
          (body
           (((Expression
              (MethodCall (Var param_names__) emplace_back ()
-              ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+              ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                 (Literal "\"p_real\"")))))
             (Expression
              (MethodCall (Var param_names__) emplace_back ()
-              ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+              ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                 (Literal "\"p_upper\"")))))
             (Expression
              (MethodCall (Var param_names__) emplace_back ()
-              ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+              ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                 (Literal "\"p_lower\"")))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 5)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"offset_multiplier\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 5)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"no_offset_multiplier\"") Add (Literal '.'))
                     Add (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 5)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"offset_no_multiplier\"") Add (Literal '.'))
                     Add (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"p_real_1d_ar\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var K)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var M)) (Increment (Var sym2__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym3__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym3__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym3__) LEq (Var N)) (Increment (Var sym3__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp
@@ -12863,28 +13433,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"p_vec\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp
                        (BinOp
                         (BinOp (BinOp (Literal "\"p_1d_vec\"") Add (Literal '.')) Add
@@ -12892,28 +13462,28 @@
                         Add (Literal '.'))
                        Add (FunCall std::to_string () ((Var sym1__))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym3__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym3__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym4__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym4__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -12930,28 +13500,28 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"p_row_vec\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp
                        (BinOp
                         (BinOp (BinOp (Literal "\"p_1d_row_vec\"") Add (Literal '.')) Add
@@ -12959,28 +13529,28 @@
                         Add (Literal '.'))
                        Add (FunCall std::to_string () ((Var sym1__))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym3__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym3__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym4__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym4__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -12997,18 +13567,18 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Literal 5)) (Increment (Var sym2__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp
                        (BinOp
                         (BinOp (BinOp (Literal "\"p_mat\"") Add (Literal '.')) Add
@@ -13016,28 +13586,28 @@
                         Add (Literal '.'))
                        Add (FunCall std::to_string () ((Var sym1__))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym3__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym3__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym4__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym4__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym4__) LEq (Literal 4)) (Increment (Var sym4__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -13054,30 +13624,30 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Parens (BinOp (Var N) Subtract (Literal 1))))
              (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"p_simplex\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Parens (BinOp (Var N) Subtract (Literal 1))))
              (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp
                        (BinOp
                         (BinOp (BinOp (Literal "\"p_1d_simplex\"") Add (Literal '.')) Add
@@ -13085,29 +13655,29 @@
                         Add (Literal '.'))
                        Add (FunCall std::to_string () ((Var sym1__))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Parens (BinOp (Var N) Subtract (Literal 1))))
              (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym3__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym3__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym4__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym4__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -13124,7 +13694,7 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq
               (Parens
@@ -13146,11 +13716,11 @@
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"p_cfcov_54\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq
               (Parens
@@ -13172,11 +13742,11 @@
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"p_cfcov_33\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq
               (Parens
@@ -13197,13 +13767,13 @@
              (Increment (Var sym1__))
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym2__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym2__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp
                        (BinOp
                         (BinOp (BinOp (Literal "\"p_cfcov_33_ar\"") Add (Literal '.'))
@@ -13211,55 +13781,55 @@
                         Add (Literal '.'))
                        Add (FunCall std::to_string () ((Var sym1__))))))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 2)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"x_p\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (For
-             ((static false) (constexpr false) (type_ Int) (name sym1__)
+             ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
               (init (Assignment (Literal 1))))
              (BinOp (Var sym1__) LEq (Literal 2)) (Increment (Var sym1__))
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (BinOp (BinOp (Literal "\"y_p\"") Add (Literal '.')) Add
                     (FunCall std::to_string () ((Var sym1__)))))))))))
             (IfElse (Var emit_transformed_parameters__)
              (Block
               ((For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"tp_real_1d_ar\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var K)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var M)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var N)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -13272,28 +13842,28 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"tp_vec\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"tp_1d_vec\"") Add (Literal '.')) Add
@@ -13301,28 +13871,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -13339,28 +13909,28 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"tp_row_vec\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"tp_1d_row_vec\"") Add (Literal '.'))
@@ -13368,28 +13938,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -13407,18 +13977,18 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 5)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"tp_mat\"") Add (Literal '.')) Add
@@ -13426,28 +13996,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Literal 4)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -13464,30 +14034,30 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Parens (BinOp (Var N) Subtract (Literal 1))))
                 (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"tp_simplex\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Parens (BinOp (Var N) Subtract (Literal 1))))
                 (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"tp_1d_simplex\"") Add (Literal '.'))
@@ -13495,29 +14065,29 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Parens (BinOp (Var N) Subtract (Literal 1))))
                 (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -13535,7 +14105,7 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq
                  (Parens
@@ -13557,11 +14127,11 @@
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"tp_cfcov_54\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq
                  (Parens
@@ -13583,11 +14153,11 @@
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"tp_cfcov_33\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq
                  (Parens
@@ -13608,13 +14178,13 @@
                 (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp
@@ -13623,58 +14193,58 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 2)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"theta_p\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (Literal "\"tp_real\"")))))))
              ())
             (IfElse (Var emit_generated_quantities__)
              (Block
               ((Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (Literal "\"gq_r1\"")))))
                (Expression
                 (MethodCall (Var param_names__) emplace_back ()
-                 ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                 ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                    (Literal "\"gq_r2\"")))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"gq_real_1d_ar\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var K)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var M)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var N)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -13687,28 +14257,28 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"gq_vec\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"gq_1d_vec\"") Add (Literal '.')) Add
@@ -13716,28 +14286,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -13754,28 +14324,28 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"gq_row_vec\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"gq_1d_row_vec\"") Add (Literal '.'))
@@ -13783,28 +14353,28 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -13822,28 +14392,28 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Literal 4)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -13860,30 +14430,30 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Parens (BinOp (Var N) Subtract (Literal 1))))
                 (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"gq_simplex\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Parens (BinOp (Var N) Subtract (Literal 1))))
                 (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"gq_1d_simplex\"") Add (Literal '.'))
@@ -13891,29 +14461,29 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Parens (BinOp (Var N) Subtract (Literal 1))))
                 (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                       (Block
                        ((For
-                         ((static false) (constexpr false) (type_ Int) 
+                         ((static false) (constexpr false) (type_ (Int AoS))
                           (name sym4__) (init (Assignment (Literal 1))))
                          (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                          (Block
                           ((Expression
                             (MethodCall (Var param_names__) emplace_back ()
-                             ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                             ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                                (BinOp
                                 (BinOp
                                  (BinOp
@@ -13931,7 +14501,7 @@
                                  Add (Literal '.'))
                                 Add (FunCall std::to_string () ((Var sym1__))))))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq
                  (Parens
@@ -13953,11 +14523,11 @@
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"gq_cfcov_54\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq
                  (Parens
@@ -13979,11 +14549,11 @@
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"gq_cfcov_33\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq
                  (Parens
@@ -14004,13 +14574,13 @@
                 (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp
@@ -14019,33 +14589,33 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((Expression
                    (MethodCall (Var param_names__) emplace_back ()
-                    ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                    ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                       (BinOp (BinOp (Literal "\"indices\"") Add (Literal '.')) Add
                        (FunCall std::to_string () ((Var sym1__)))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -14058,23 +14628,23 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 3)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -14086,23 +14656,23 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -14114,23 +14684,23 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 3)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -14142,23 +14712,23 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 3)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -14171,23 +14741,23 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -14200,23 +14770,23 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((For
-                      ((static false) (constexpr false) (type_ Int) (name sym3__)
-                       (init (Assignment (Literal 1))))
+                      ((static false) (constexpr false) (type_ (Int AoS)) 
+                       (name sym3__) (init (Assignment (Literal 1))))
                       (BinOp (Var sym3__) LEq (Literal 3)) (Increment (Var sym3__))
                       (Block
                        ((Expression
                          (MethodCall (Var param_names__) emplace_back ()
-                          ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                          ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                             (BinOp
                              (BinOp
                               (BinOp
@@ -14229,18 +14799,18 @@
                               Add (Literal '.'))
                              Add (FunCall std::to_string () ((Var sym1__)))))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"idx_res4\"") Add (Literal '.')) Add
@@ -14248,18 +14818,18 @@
                            Add (Literal '.'))
                           Add (FunCall std::to_string () ((Var sym1__))))))))))))))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym1__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym1__) LEq (Literal 2)) (Increment (Var sym1__))
                 (Block
                  ((For
-                   ((static false) (constexpr false) (type_ Int) (name sym2__)
-                    (init (Assignment (Literal 1))))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name sym2__) (init (Assignment (Literal 1))))
                    (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                    (Block
                     ((Expression
                       (MethodCall (Var param_names__) emplace_back ()
-                       ((BinOp (Constructor (TypeLiteral std::string) ()) Add
+                       ((BinOp (Constructor (TypeLiteral std::string AoS) ()) Add
                          (BinOp
                           (BinOp
                            (BinOp (BinOp (Literal "\"idx_res5\"") Add (Literal '.')) Add
@@ -14269,20 +14839,20 @@
              ()))))))
        (FunDef
         ((templates_init ((()) false)) (inline true)
-         (return_type (TypeLiteral std::string)) (name get_constrained_sizedtypes)
+         (return_type (TypeLiteral std::string AoS)) (name get_constrained_sizedtypes)
          (args ()) (cv_qualifiers (Const))
          (body
           (((Return
-             ((Constructor (TypeLiteral std::string)
+             ((Constructor (TypeLiteral std::string AoS)
                ((Literal
                  "\"[{\\\"name\\\":\\\"p_real\\\",\\\"type\\\":{\\\"name\\\":\\\"real\\\"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_upper\\\",\\\"type\\\":{\\\"name\\\":\\\"real\\\"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_lower\\\",\\\"type\\\":{\\\"name\\\":\\\"real\\\"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"offset_multiplier\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"no_offset_multiplier\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"offset_no_multiplier\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_real_1d_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_real_3d_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}}}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_1d_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_3d_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_1d_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_3d_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_mat\\\",\\\"type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(5) + \",\\\"cols\\\":\" + std::to_string(4) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_ar_mat\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(4) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(2) + \",\\\"cols\\\":\" + std::to_string(3) + \"}}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_1d_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_3d_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_cfcov_54\\\",\\\"type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(5) + \",\\\"cols\\\":\" + std::to_string(4) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_cfcov_33\\\",\\\"type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(3) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_cfcov_33_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(3) + \"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"x_p\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(2) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"y_p\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(2) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"tp_real_1d_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_real_3d_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}}}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_1d_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_3d_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_1d_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_3d_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_mat\\\",\\\"type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(5) + \",\\\"cols\\\":\" + std::to_string(4) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_ar_mat\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(4) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(2) + \",\\\"cols\\\":\" + std::to_string(3) + \"}}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_1d_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_3d_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_cfcov_54\\\",\\\"type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(5) + \",\\\"cols\\\":\" + std::to_string(4) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_cfcov_33\\\",\\\"type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(3) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_cfcov_33_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(3) + \"}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"theta_p\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(2) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_real\\\",\\\"type\\\":{\\\"name\\\":\\\"real\\\"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"gq_r1\\\",\\\"type\\\":{\\\"name\\\":\\\"real\\\"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_r2\\\",\\\"type\\\":{\\\"name\\\":\\\"real\\\"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_real_1d_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_real_3d_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}}}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_1d_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_3d_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_1d_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_3d_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_ar_mat\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(4) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(2) + \",\\\"cols\\\":\" + std::to_string(3) + \"}}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_1d_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_3d_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_cfcov_54\\\",\\\"type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(5) + \",\\\"cols\\\":\" + std::to_string(4) + \"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_cfcov_33\\\",\\\"type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(3) + \"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_cfcov_33_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(3) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"indices\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(3) + \",\\\"element_type\\\":{\\\"name\\\":\\\"int\\\"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"indexing_mat\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(4) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res1\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(3) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(4) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res2\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(4) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res3\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(3) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(3) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res11\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(3) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(4) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res21\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(4) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res31\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(3) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(3) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res4\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(3) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(4) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res5\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(2) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(2) + \"}},\\\"block\\\":\\\"generated_quantities\\\"}]\""))))))))))
        (FunDef
         ((templates_init ((()) false)) (inline true)
-         (return_type (TypeLiteral std::string)) (name get_unconstrained_sizedtypes)
+         (return_type (TypeLiteral std::string AoS)) (name get_unconstrained_sizedtypes)
          (args ()) (cv_qualifiers (Const))
          (body
           (((Return
-             ((Constructor (TypeLiteral std::string)
+             ((Constructor (TypeLiteral std::string AoS)
                ((Literal
                  "\"[{\\\"name\\\":\\\"p_real\\\",\\\"type\\\":{\\\"name\\\":\\\"real\\\"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_upper\\\",\\\"type\\\":{\\\"name\\\":\\\"real\\\"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_lower\\\",\\\"type\\\":{\\\"name\\\":\\\"real\\\"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"offset_multiplier\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"no_offset_multiplier\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"offset_no_multiplier\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_real_1d_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_real_3d_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}}}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_1d_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_3d_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_1d_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_3d_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_mat\\\",\\\"type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(5) + \",\\\"cols\\\":\" + std::to_string(4) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_ar_mat\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(4) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(2) + \",\\\"cols\\\":\" + std::to_string(3) + \"}}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string((N -1)) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_1d_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string((N -1)) + \"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_3d_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string((N -1)) + \"}}}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_cfcov_54\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(((((4 * (4 - 1)) / 2) + 4) + ((5 - 4) *4))) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_cfcov_33\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(((((3 * (3 - 1)) / 2) + 3) + ((3 - 3) *3))) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"p_cfcov_33_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(((((3 * (3 - 1)) / 2) + 3) + ((3 - 3) *3))) + \"}},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"x_p\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(2) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"y_p\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(2) + \"},\\\"block\\\":\\\"parameters\\\"},{\\\"name\\\":\\\"tp_real_1d_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_real_3d_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}}}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_1d_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_3d_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_1d_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_3d_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_mat\\\",\\\"type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(5) + \",\\\"cols\\\":\" + std::to_string(4) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_ar_mat\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(4) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(2) + \",\\\"cols\\\":\" + std::to_string(3) + \"}}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string((N -1)) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_1d_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string((N -1)) + \"}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_3d_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string((N -1)) + \"}}}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_cfcov_54\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(((((4 * (4 - 1)) / 2) + 4) + ((5 - 4) *4))) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_cfcov_33\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(((((3 * (3 - 1)) / 2) + 3) + ((3 - 3) *3))) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_cfcov_33_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(((((3 * (3 - 1)) / 2) + 3) + ((3 - 3) *3))) + \"}},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"theta_p\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(2) + \"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"tp_real\\\",\\\"type\\\":{\\\"name\\\":\\\"real\\\"},\\\"block\\\":\\\"transformed_parameters\\\"},{\\\"name\\\":\\\"gq_r1\\\",\\\"type\\\":{\\\"name\\\":\\\"real\\\"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_r2\\\",\\\"type\\\":{\\\"name\\\":\\\"real\\\"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_real_1d_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_real_3d_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"real\\\"}}}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_1d_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_3d_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_1d_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_3d_row_vec\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(N) + \"}}}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_ar_mat\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(4) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(2) + \",\\\"cols\\\":\" + std::to_string(3) + \"}}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string((N -1)) + \"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_1d_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string((N -1)) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_3d_simplex\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(N) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(M) + \",\\\"element_type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string((N -1)) + \"}}}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_cfcov_54\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(((((4 * (4 - 1)) / 2) + 4) + ((5 - 4) *4))) + \"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_cfcov_33\\\",\\\"type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(((((3 * (3 - 1)) / 2) + 3) + ((3 - 3) *3))) + \"},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"gq_cfcov_33_ar\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(K) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(((((3 * (3 - 1)) / 2) + 3) + ((3 - 3) *3))) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"indices\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(3) + \",\\\"element_type\\\":{\\\"name\\\":\\\"int\\\"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"indexing_mat\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(4) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res1\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(3) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(4) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res2\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(4) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res3\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(3) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(3) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res11\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(3) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(4) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res21\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(5) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(4) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res31\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(3) + \",\\\"element_type\\\":{\\\"name\\\":\\\"matrix\\\",\\\"rows\\\":\" + std::to_string(3) + \",\\\"cols\\\":\" + std::to_string(3) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res4\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(3) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(4) + \"}},\\\"block\\\":\\\"generated_quantities\\\"},{\\\"name\\\":\\\"idx_res5\\\",\\\"type\\\":{\\\"name\\\":\\\"array\\\",\\\"length\\\":\" + std::to_string(2) + \",\\\"element_type\\\":{\\\"name\\\":\\\"vector\\\",\\\"length\\\":\" + std::to_string(2) + \"}},\\\"block\\\":\\\"generated_quantities\\\"}]\""))))))))))
        (GlobalComment "Begin method overload boilerplate")
@@ -14290,15 +14860,16 @@
         ((templates_init ((((Typename RNG))) false)) (inline true) (return_type Void)
          (name write_array)
          (args
-          (((Ref (TemplateType RNG)) base_rng) ((Ref (Matrix Double -1 1 AoS)) params_r)
-           ((Ref (Matrix Double -1 1 AoS)) vars)
-           ((Const (TypeLiteral bool)) "emit_transformed_parameters = true")
-           ((Const (TypeLiteral bool)) "emit_generated_quantities = true")
-           ((Pointer (TypeLiteral std::ostream)) "pstream = nullptr")))
+          (((Ref (TemplateType RNG)) base_rng)
+           ((Ref (Matrix (Double AoS) -1 1 AoS)) params_r)
+           ((Ref (Matrix (Double AoS) -1 1 AoS)) vars)
+           ((Const (TypeLiteral bool AoS)) "emit_transformed_parameters = true")
+           ((Const (TypeLiteral bool AoS)) "emit_generated_quantities = true")
+           ((Pointer (TypeLiteral std::ostream AoS)) "pstream = nullptr")))
          (cv_qualifiers (Const))
          (body
           (((VariableDefn
-             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t)))
+             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t AoS)))
               (name num_params__)
               (init
                (Assignment
@@ -14401,7 +14972,7 @@
                     Add (Literal 2)))
                   Add (Literal 2)))))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t)))
+             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t AoS)))
               (name num_transformed)
               (init
                (Assignment
@@ -14488,7 +15059,7 @@
                       Add (Literal 2)))
                     Add (Literal 1)))))))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t)))
+             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t AoS)))
               (name num_gen_quantities)
               (init
                (Assignment
@@ -14646,18 +15217,18 @@
                       Add (Parens (BinOp (Literal 3) Multiply (Literal 4)))))
                     Add (Parens (BinOp (Literal 2) Multiply (Literal 2)))))))))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t)))
+             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t AoS)))
               (name num_to_write)
               (init
                (Assignment
                 (BinOp (BinOp (Var num_params__) Add (Var num_transformed)) Add
                  (Var num_gen_quantities))))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (StdVector Int)) 
+             ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
               (name params_i) (init Uninitialized)))
             (Expression
              (Assign (Var vars)
-              (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+              (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                ((Var num_to_write)
                 (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
             (Expression
@@ -14669,15 +15240,17 @@
         ((templates_init ((((Typename RNG))) false)) (inline true) (return_type Void)
          (name write_array)
          (args
-          (((Ref (TemplateType RNG)) base_rng) ((Ref (StdVector Double)) params_r)
-           ((Ref (StdVector Int)) params_i) ((Ref (StdVector Double)) vars)
-           ((TypeLiteral bool) "emit_transformed_parameters = true")
-           ((TypeLiteral bool) "emit_generated_quantities = true")
-           ((Pointer (TypeLiteral std::ostream)) "pstream = nullptr")))
+          (((Ref (TemplateType RNG)) base_rng)
+           ((Ref (StdVector (Double AoS) AoS)) params_r)
+           ((Ref (StdVector (Int AoS) AoS)) params_i)
+           ((Ref (StdVector (Double AoS) AoS)) vars)
+           ((TypeLiteral bool AoS) "emit_transformed_parameters = true")
+           ((TypeLiteral bool AoS) "emit_generated_quantities = true")
+           ((Pointer (TypeLiteral std::ostream AoS)) "pstream = nullptr")))
          (cv_qualifiers (Const))
          (body
           (((VariableDefn
-             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t)))
+             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t AoS)))
               (name num_params__)
               (init
                (Assignment
@@ -14780,7 +15353,7 @@
                     Add (Literal 2)))
                   Add (Literal 2)))))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t)))
+             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t AoS)))
               (name num_transformed)
               (init
                (Assignment
@@ -14867,7 +15440,7 @@
                       Add (Literal 2)))
                     Add (Literal 1)))))))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t)))
+             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t AoS)))
               (name num_gen_quantities)
               (init
                (Assignment
@@ -15025,7 +15598,7 @@
                       Add (Parens (BinOp (Literal 3) Multiply (Literal 4)))))
                     Add (Parens (BinOp (Literal 2) Multiply (Literal 2)))))))))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t)))
+             ((static false) (constexpr false) (type_ (Const (TypeLiteral size_t AoS)))
               (name num_to_write)
               (init
                (Assignment
@@ -15033,7 +15606,7 @@
                  (Var num_gen_quantities))))))
             (Expression
              (Assign (Var vars)
-              (Constructor (StdVector Double)
+              (Constructor (StdVector (Double AoS) AoS)
                ((Var num_to_write)
                 (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
             (Expression
@@ -15046,11 +15619,11 @@
          (inline true) (return_type (TemplateType T_)) (name log_prob)
          (args
           (((Ref (Matrix (TemplateType T_) -1 1 AoS)) params_r)
-           ((Pointer (TypeLiteral std::ostream)) "pstream = nullptr")))
+           ((Pointer (TypeLiteral std::ostream AoS)) "pstream = nullptr")))
          (cv_qualifiers (Const))
          (body
           (((VariableDefn
-             ((static false) (constexpr false) (type_ (Matrix Int -1 1 AoS))
+             ((static false) (constexpr false) (type_ (Matrix (Int AoS) -1 1 AoS))
               (name params_i) (init Uninitialized)))
             (Return
              ((FunCall log_prob_impl ((TemplateType propto__) (TemplateType jacobian__))
@@ -15059,9 +15632,9 @@
         ((templates_init ((((Bool propto__) (Bool jacobian__) (Typename T_))) false))
          (inline true) (return_type (TemplateType T_)) (name log_prob)
          (args
-          (((Ref (StdVector (TemplateType T_))) params_r)
-           ((Ref (StdVector Int)) params_i)
-           ((Pointer (TypeLiteral std::ostream)) "pstream = nullptr")))
+          (((Ref (StdVector (TemplateType T_) AoS)) params_r)
+           ((Ref (StdVector (Int AoS) AoS)) params_i)
+           ((Pointer (TypeLiteral std::ostream AoS)) "pstream = nullptr")))
          (cv_qualifiers (Const))
          (body
           (((Return
@@ -15071,33 +15644,34 @@
         ((templates_init ((()) false)) (inline true) (return_type Void)
          (name transform_inits)
          (args
-          (((Const (Ref (TypeLiteral stan::io::var_context))) context)
-           ((Ref (Matrix Double -1 1 AoS)) params_r)
-           ((Pointer (TypeLiteral std::ostream)) "pstream = nullptr")))
+          (((Const (Ref (TypeLiteral stan::io::var_context AoS))) context)
+           ((Ref (Matrix (Double AoS) -1 1 AoS)) params_r)
+           ((Pointer (TypeLiteral std::ostream AoS)) "pstream = nullptr")))
          (cv_qualifiers (Const Final))
          (body
           (((VariableDefn
-             ((static false) (constexpr false) (type_ (StdVector Double))
+             ((static false) (constexpr false) (type_ (StdVector (Double AoS) AoS))
               (name params_r_vec)
               (init (Construction ((MethodCall (Var params_r) size () ()))))))
             (VariableDefn
-             ((static false) (constexpr false) (type_ (StdVector Int)) 
+             ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
               (name params_i) (init Uninitialized)))
             (Expression
              (FunCall transform_inits ()
               ((Var context) (Var params_i) (Var params_r_vec) (Var pstream))))
             (Expression
              (Assign (Var params_r)
-              (Constructor (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))
+              (Constructor (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS)))
                ((MethodCall (Var params_r_vec) data () ())
                 (MethodCall (Var params_r_vec) size () ()))))))))))
        (FunDef
         ((templates_init ((()) false)) (inline true) (return_type Void)
          (name transform_inits)
          (args
-          (((Const (Ref (TypeLiteral stan::io::var_context))) context)
-           ((Ref (StdVector Int)) params_i) ((Ref (StdVector Double)) vars)
-           ((Pointer (TypeLiteral std::ostream)) "pstream__ = nullptr")))
+          (((Const (Ref (TypeLiteral stan::io::var_context AoS))) context)
+           ((Ref (StdVector (Int AoS) AoS)) params_i)
+           ((Ref (StdVector (Double AoS) AoS)) vars)
+           ((Pointer (TypeLiteral std::ostream AoS)) "pstream__ = nullptr")))
          (cv_qualifiers (Const))
          (body
           (((Expression (MethodCall (Var vars) resize () ((Var num_params_r__))))
@@ -15107,17 +15681,17 @@
         ((templates_init ((()) false)) (inline true) (return_type Void)
          (name unconstrain_array)
          (args
-          (((Const (Ref (StdVector Double))) params_constrained)
-           ((Ref (StdVector Double)) params_unconstrained)
-           ((Pointer (TypeLiteral std::ostream)) "pstream = nullptr")))
+          (((Const (Ref (StdVector (Double AoS) AoS))) params_constrained)
+           ((Ref (StdVector (Double AoS) AoS)) params_unconstrained)
+           ((Pointer (TypeLiteral std::ostream AoS)) "pstream = nullptr")))
          (cv_qualifiers (Const))
          (body
           (((VariableDefn
-             ((static false) (constexpr false) (type_ (Const (StdVector Int)))
+             ((static false) (constexpr false) (type_ (Const (StdVector (Int AoS) AoS)))
               (name params_i) (init Uninitialized)))
             (Expression
              (Assign (Var params_unconstrained)
-              (Constructor (StdVector Double)
+              (Constructor (StdVector (Double AoS) AoS)
                ((Var num_params_r__)
                 (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
             (Expression
@@ -15128,17 +15702,17 @@
         ((templates_init ((()) false)) (inline true) (return_type Void)
          (name unconstrain_array)
          (args
-          (((Const (Ref (Matrix Double -1 1 AoS))) params_constrained)
-           ((Ref (Matrix Double -1 1 AoS)) params_unconstrained)
-           ((Pointer (TypeLiteral std::ostream)) "pstream = nullptr")))
+          (((Const (Ref (Matrix (Double AoS) -1 1 AoS))) params_constrained)
+           ((Ref (Matrix (Double AoS) -1 1 AoS)) params_unconstrained)
+           ((Pointer (TypeLiteral std::ostream AoS)) "pstream = nullptr")))
          (cv_qualifiers (Const))
          (body
           (((VariableDefn
-             ((static false) (constexpr false) (type_ (Const (StdVector Int)))
+             ((static false) (constexpr false) (type_ (Const (StdVector (Int AoS) AoS)))
               (name params_i) (init Uninitialized)))
             (Expression
              (Assign (Var params_unconstrained)
-              (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+              (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                ((Var num_params_r__)
                 (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
             (Expression
@@ -15147,17 +15721,17 @@
                (Var pstream)))))))))))
      (constructor
       ((args
-        (((Ref (TypeLiteral stan::io::var_context)) context__)
-         ((TypeLiteral "unsigned int") "random_seed__ = 0")
-         ((Pointer (TypeLiteral std::ostream)) "pstream__ = nullptr")))
+        (((Ref (TypeLiteral stan::io::var_context AoS)) context__)
+         ((TypeLiteral "unsigned int" AoS) "random_seed__ = 0")
+         ((Pointer (TypeLiteral std::ostream AoS)) "pstream__ = nullptr")))
        (init_list ((model_base_crtp ((Literal 0)))))
        (body
         ((VariableDefn
-          ((static false) (constexpr false) (type_ Int) (name current_statement__)
+          ((static false) (constexpr false) (type_ (Int AoS)) (name current_statement__)
            (init (Assignment (Literal 0)))))
-         (Using local_scalar_t__ (Double))
+         (Using local_scalar_t__ ((Double AoS)))
          (VariableDefn
-          ((static false) (constexpr false) (type_ (TypeLiteral boost::ecuyer1988))
+          ((static false) (constexpr false) (type_ (TypeLiteral boost::ecuyer1988 AoS))
            (name base_rng__)
            (init
             (Assignment
@@ -15166,27 +15740,27 @@
          (Comment "suppress unused var warning")
          (Expression (Cast Void (Var base_rng__)))
          (VariableDefn
-          ((static true) (constexpr true) (type_ (Const (Pointer (TypeLiteral char))))
-           (name function__)
+          ((static true) (constexpr true)
+           (type_ (Const (Pointer (TypeLiteral char AoS)))) (name function__)
            (init (Assignment (Literal "\"mother_model_namespace::mother_model\"")))))
          (Comment "suppress unused var warning")
          (Expression (Cast Void (Var function__)))
          (VariableDefn
-          ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__))
+          ((static false) (constexpr false) (type_ (TypeLiteral local_scalar_t__ AoS))
            (name DUMMY_VAR__)
            (init (Construction ((FunCall std::numeric_limits<double>::quiet_NaN () ()))))))
          (Comment "suppress unused var warning")
          (Expression (Cast Void (Var DUMMY_VAR__)))
          (TryCatch
           ((VariableDefn
-            ((static false) (constexpr false) (type_ Int) (name pos__)
+            ((static false) (constexpr false) (type_ (Int AoS)) (name pos__)
              (init (Assignment (FunCall std::numeric_limits<int>::min () ())))))
            (Expression (Assign (Var pos__) (Literal 1)))
            (Expression (Assign (Var current_statement__) (Literal 190)))
            (Expression
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"N\"") (Literal "\"int\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t)) ()))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ()))))
            (Expression (Assign (Var N) (FunCall std::numeric_limits<int>::min () ())))
            (Expression (Assign (Var current_statement__) (Literal 190)))
            (Expression
@@ -15201,7 +15775,7 @@
            (Expression
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"M\"") (Literal "\"int\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t)) ()))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ()))))
            (Expression (Assign (Var M) (FunCall std::numeric_limits<int>::min () ())))
            (Expression (Assign (Var current_statement__) (Literal 191)))
            (Expression
@@ -15216,7 +15790,7 @@
            (Expression
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"K\"") (Literal "\"int\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t)) ()))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ()))))
            (Expression (Assign (Var K) (FunCall std::numeric_limits<int>::min () ())))
            (Expression (Assign (Var current_statement__) (Literal 192)))
            (Expression
@@ -15241,11 +15815,11 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_int_1d_ar\"")
               (Literal "\"int\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
            (Expression
             (Assign (Var d_int_1d_ar)
-             (Constructor (StdVector Int)
+             (Constructor (StdVector (Int AoS) AoS)
               ((Var N) (FunCall std::numeric_limits<int>::min () ())))))
            (Expression (Assign (Var current_statement__) (Literal 194)))
            (Expression
@@ -15272,21 +15846,21 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_int_3d_ar\"")
               (Literal "\"int\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var K))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K))))))))
            (Expression
             (Assign (Var d_int_3d_ar)
-             (Constructor (StdVector (StdVector (StdVector Int)))
+             (Constructor (StdVector (StdVector (StdVector (Int AoS) AoS) AoS) AoS)
               ((Var N)
-               (Constructor (StdVector (StdVector Int))
+               (Constructor (StdVector (StdVector (Int AoS) AoS) AoS)
                 ((Var M)
-                 (Constructor (StdVector Int)
+                 (Constructor (StdVector (Int AoS) AoS)
                   ((Var K) (FunCall std::numeric_limits<int>::min () ())))))))))
            (Block
             ((VariableDefn
-              ((static false) (constexpr false) (type_ (StdVector Int))
+              ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
                (name d_int_3d_ar_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 198)))
              (Expression
@@ -15294,18 +15868,18 @@
                (MethodCall (Var context__) vals_i () ((Literal "\"d_int_3d_ar\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var K)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var M)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Var N)) (Increment (Var sym3__))
                     (Block
                      ((Expression
@@ -15328,7 +15902,7 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"J\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t)) ()))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ()))))
            (Expression
             (Assign (Var J) (FunCall std::numeric_limits<double>::quiet_NaN () ())))
            (Expression (Assign (Var current_statement__) (Literal 199)))
@@ -15353,11 +15927,11 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_real_1d_ar\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
            (Expression
             (Assign (Var d_real_1d_ar)
-             (Constructor (StdVector Double)
+             (Constructor (StdVector (Double AoS) AoS)
               ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression (Assign (Var current_statement__) (Literal 201)))
            (Expression
@@ -15380,22 +15954,22 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_real_3d_ar\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var K))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K))))))))
            (Expression
             (Assign (Var d_real_3d_ar)
-             (Constructor (StdVector (StdVector (StdVector Double)))
+             (Constructor (StdVector (StdVector (StdVector (Double AoS) AoS) AoS) AoS)
               ((Var N)
-               (Constructor (StdVector (StdVector Double))
+               (Constructor (StdVector (StdVector (Double AoS) AoS) AoS)
                 ((Var M)
-                 (Constructor (StdVector Double)
+                 (Constructor (StdVector (Double AoS) AoS)
                   ((Var K) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_real_3d_ar_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 205)))
              (Expression
@@ -15403,18 +15977,18 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_real_3d_ar\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var K)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var M)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Var N)) (Increment (Var sym3__))
                     (Block
                      ((Expression
@@ -15437,27 +16011,27 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_vec\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
            (Expression
             (Assign (Var d_vec_data__)
-             (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
               ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
-            (OperatorNew d_vec (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))
+            (OperatorNew d_vec (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS)))
              ((MethodCall (Var d_vec_data__) data () ()) (Var N))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__))) (name d_vec_flat__)
-               (init Uninitialized)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+               (name d_vec_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 207)))
              (Expression
               (Assign (Var d_vec_flat__)
                (MethodCall (Var context__) vals_r () ((Literal "\"d_vec\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
               (Block
@@ -15483,33 +16057,33 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_1d_vec\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
            (Expression
             (Assign (Var d_1d_vec)
-             (Constructor (StdVector (Matrix Double -1 1 AoS))
+             (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
               ((Var N)
-               (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+               (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                 ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__))) (name d_1d_vec_flat__)
-               (init Uninitialized)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+               (name d_1d_vec_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 210)))
              (Expression
               (Assign (Var d_1d_vec_flat__)
                (MethodCall (Var context__) vals_r () ((Literal "\"d_1d_vec\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                  (Block
                   ((Expression
@@ -15543,48 +16117,51 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_3d_vec\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
            (Expression
             (Assign (Var d_3d_vec)
-             (Constructor (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS))))
+             (Constructor
+              (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
+               AoS)
               ((Var N)
-               (Constructor (StdVector (StdVector (Matrix Double -1 1 AoS)))
+               (Constructor
+                (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
                 ((Var M)
-                 (Constructor (StdVector (Matrix Double -1 1 AoS))
+                 (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                   ((Var K)
-                   (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                   (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                     ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__))) (name d_3d_vec_flat__)
-               (init Uninitialized)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+               (name d_3d_vec_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 215)))
              (Expression
               (Assign (Var d_3d_vec_flat__)
                (MethodCall (Var context__) vals_r () ((Literal "\"d_3d_vec\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym4__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                        (Block
@@ -15610,27 +16187,28 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_row_vec\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
            (Expression
             (Assign (Var d_row_vec_data__)
-             (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
               ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
-            (OperatorNew d_row_vec (TypeTrait Eigen::Map ((Matrix Double 1 -1 AoS)))
+            (OperatorNew d_row_vec
+             (TypeTrait Eigen::Map ((Matrix (Double AoS) 1 -1 AoS)))
              ((MethodCall (Var d_row_vec_data__) data () ()) (Var N))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__))) (name d_row_vec_flat__)
-               (init Uninitialized)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+               (name d_row_vec_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 217)))
              (Expression
               (Assign (Var d_row_vec_flat__)
                (MethodCall (Var context__) vals_r () ((Literal "\"d_row_vec\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
               (Block
@@ -15656,19 +16234,19 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_1d_row_vec\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
            (Expression
             (Assign (Var d_1d_row_vec)
-             (Constructor (StdVector (Matrix Double 1 -1 AoS))
+             (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
               ((Var N)
-               (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+               (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                 ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_1d_row_vec_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 220)))
              (Expression
@@ -15676,13 +16254,13 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_1d_row_vec\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                  (Block
                   ((Expression
@@ -15716,25 +16294,28 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_3d_row_vec\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
            (Expression
             (Assign (Var d_3d_row_vec)
-             (Constructor (StdVector (StdVector (StdVector (Matrix Double 1 -1 AoS))))
+             (Constructor
+              (StdVector (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS)
+               AoS)
               ((Var N)
-               (Constructor (StdVector (StdVector (Matrix Double 1 -1 AoS)))
+               (Constructor
+                (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS)
                 ((Var M)
-                 (Constructor (StdVector (Matrix Double 1 -1 AoS))
+                 (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
                   ((Var K)
-                   (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                   (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                     ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_3d_row_vec_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 225)))
              (Expression
@@ -15742,22 +16323,22 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_3d_row_vec\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym4__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                        (Block
@@ -15779,47 +16360,47 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_ar_mat\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 4)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3))))))))
            (Expression
             (Assign (Var d_ar_mat)
-             (Constructor (StdVector (StdVector (Matrix Double -1 -1 AoS)))
+             (Constructor (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS)
               ((Literal 4)
-               (Constructor (StdVector (Matrix Double -1 -1 AoS))
+               (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                 ((Literal 5)
-                 (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                 (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                   ((Literal 2) (Literal 3)
                    (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__))) (name d_ar_mat_flat__)
-               (init Uninitialized)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+               (name d_ar_mat_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 226)))
              (Expression
               (Assign (Var d_ar_mat_flat__)
                (MethodCall (Var context__) vals_r () ((Literal "\"d_ar_mat\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Literal 5)) (Increment (Var sym3__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym4__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym4__) LEq (Literal 4)) (Increment (Var sym4__))
                        (Block
@@ -15853,27 +16434,28 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_simplex\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
            (Expression
             (Assign (Var d_simplex_data__)
-             (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
               ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
-            (OperatorNew d_simplex (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))
+            (OperatorNew d_simplex
+             (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS)))
              ((MethodCall (Var d_simplex_data__) data () ()) (Var N))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__))) (name d_simplex_flat__)
-               (init Uninitialized)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+               (name d_simplex_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 228)))
              (Expression
               (Assign (Var d_simplex_flat__)
                (MethodCall (Var context__) vals_r () ((Literal "\"d_simplex\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
               (Block
@@ -15903,19 +16485,19 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_1d_simplex\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
            (Expression
             (Assign (Var d_1d_simplex)
-             (Constructor (StdVector (Matrix Double -1 1 AoS))
+             (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
               ((Var N)
-               (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+               (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                 ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_1d_simplex_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 231)))
              (Expression
@@ -15923,13 +16505,13 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_1d_simplex\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var N)) (Increment (Var sym2__))
                  (Block
                   ((Expression
@@ -15967,25 +16549,28 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_3d_simplex\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var N)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var M)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var N))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var M)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var N))))))))
            (Expression
             (Assign (Var d_3d_simplex)
-             (Constructor (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS))))
+             (Constructor
+              (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
+               AoS)
               ((Var N)
-               (Constructor (StdVector (StdVector (Matrix Double -1 1 AoS)))
+               (Constructor
+                (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
                 ((Var M)
-                 (Constructor (StdVector (Matrix Double -1 1 AoS))
+                 (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                   ((Var K)
-                   (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                   (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                     ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_3d_simplex_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 236)))
              (Expression
@@ -15993,22 +16578,22 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_3d_simplex\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var N)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var K)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Var M)) (Increment (Var sym3__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym4__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym4__) LEq (Var N)) (Increment (Var sym4__))
                        (Block
@@ -16034,21 +16619,22 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_cfcov_54\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 5)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 4))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 5)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 4))))))))
            (Expression
             (Assign (Var d_cfcov_54_data__)
-             (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
               ((Literal 5) (Literal 4)
                (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
-            (OperatorNew d_cfcov_54 (TypeTrait Eigen::Map ((Matrix Double -1 -1 AoS)))
+            (OperatorNew d_cfcov_54
+             (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 -1 AoS)))
              ((MethodCall (Var d_cfcov_54_data__) data () ()) (Literal 5) (Literal 4))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_cfcov_54_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 237)))
              (Expression
@@ -16056,13 +16642,13 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_cfcov_54\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Literal 4)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Literal 5)) (Increment (Var sym2__))
                  (Block
                   ((Expression
@@ -16084,21 +16670,22 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_cfcov_33\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3))))))))
            (Expression
             (Assign (Var d_cfcov_33_data__)
-             (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
               ((Literal 3) (Literal 3)
                (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
-            (OperatorNew d_cfcov_33 (TypeTrait Eigen::Map ((Matrix Double -1 -1 AoS)))
+            (OperatorNew d_cfcov_33
+             (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 -1 AoS)))
              ((MethodCall (Var d_cfcov_33_data__) data () ()) (Literal 3) (Literal 3))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_cfcov_33_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 238)))
              (Expression
@@ -16106,13 +16693,13 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_cfcov_33\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                  (Block
                   ((Expression
@@ -16138,21 +16725,21 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_cfcov_33_ar\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var K)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var K)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3))))))))
            (Expression
             (Assign (Var d_cfcov_33_ar)
-             (Constructor (StdVector (Matrix Double -1 -1 AoS))
+             (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
               ((Var K)
-               (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+               (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                 ((Literal 3) (Literal 3)
                  (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_cfcov_33_ar_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 240)))
              (Expression
@@ -16160,18 +16747,18 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_cfcov_33_ar\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Var K)) (Increment (Var sym3__))
                     (Block
                      ((Expression
@@ -16193,7 +16780,8 @@
            (Expression
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_int\"")
-              (Literal "\"int\"") (InitializerExpr (StdVector (TypeLiteral size_t)) ()))))
+              (Literal "\"int\"")
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ()))))
            (Expression
             (Assign (Var d_int) (FunCall std::numeric_limits<int>::min () ())))
            (Expression (Assign (Var current_statement__) (Literal 241)))
@@ -16210,11 +16798,11 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_int_array\"")
               (Literal "\"int\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_int_array)
-             (Constructor (StdVector Int)
+             (Constructor (StdVector (Int AoS) AoS)
               ((Var d_int) (FunCall std::numeric_limits<int>::min () ())))))
            (Expression (Assign (Var current_statement__) (Literal 243)))
            (Expression
@@ -16229,18 +16817,18 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_int_array_2d\"")
               (Literal "\"int\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2))))))))
            (Expression
             (Assign (Var d_int_array_2d)
-             (Constructor (StdVector (StdVector Int))
+             (Constructor (StdVector (StdVector (Int AoS) AoS) AoS)
               ((Var d_int)
-               (Constructor (StdVector Int)
+               (Constructor (StdVector (Int AoS) AoS)
                 ((Literal 2) (FunCall std::numeric_limits<int>::min () ())))))))
            (Block
             ((VariableDefn
-              ((static false) (constexpr false) (type_ (StdVector Int))
+              ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
                (name d_int_array_2d_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 245)))
              (Expression
@@ -16248,13 +16836,13 @@
                (MethodCall (Var context__) vals_i () ((Literal "\"d_int_array_2d\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Literal 2)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var d_int)) (Increment (Var sym2__))
                  (Block
                   ((Expression
@@ -16276,21 +16864,21 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_int_array_3d\"")
               (Literal "\"int\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3))))))))
            (Expression
             (Assign (Var d_int_array_3d)
-             (Constructor (StdVector (StdVector (StdVector Int)))
+             (Constructor (StdVector (StdVector (StdVector (Int AoS) AoS) AoS) AoS)
               ((Var d_int)
-               (Constructor (StdVector (StdVector Int))
+               (Constructor (StdVector (StdVector (Int AoS) AoS) AoS)
                 ((Literal 2)
-                 (Constructor (StdVector Int)
+                 (Constructor (StdVector (Int AoS) AoS)
                   ((Literal 3) (FunCall std::numeric_limits<int>::min () ())))))))))
            (Block
             ((VariableDefn
-              ((static false) (constexpr false) (type_ (StdVector Int))
+              ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
                (name d_int_array_3d_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 247)))
              (Expression
@@ -16298,18 +16886,18 @@
                (MethodCall (Var context__) vals_i () ((Literal "\"d_int_array_3d\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Var d_int)) (Increment (Var sym3__))
                     (Block
                      ((Expression
@@ -16328,7 +16916,7 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_real\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t)) ()))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS) ()))))
            (Expression
             (Assign (Var d_real) (FunCall std::numeric_limits<double>::quiet_NaN () ())))
            (Expression (Assign (Var current_statement__) (Literal 248)))
@@ -16345,11 +16933,11 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_real_array\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_real_array)
-             (Constructor (StdVector Double)
+             (Constructor (StdVector (Double AoS) AoS)
               ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression (Assign (Var current_statement__) (Literal 250)))
            (Expression
@@ -16364,19 +16952,19 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_real_array_2d\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2))))))))
            (Expression
             (Assign (Var d_real_array_2d)
-             (Constructor (StdVector (StdVector Double))
+             (Constructor (StdVector (StdVector (Double AoS) AoS) AoS)
               ((Var d_int)
-               (Constructor (StdVector Double)
+               (Constructor (StdVector (Double AoS) AoS)
                 ((Literal 2) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_real_array_2d_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 252)))
              (Expression
@@ -16384,13 +16972,13 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_real_array_2d\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Literal 2)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var d_int)) (Increment (Var sym2__))
                  (Block
                   ((Expression
@@ -16412,22 +17000,22 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_real_array_3d\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3))))))))
            (Expression
             (Assign (Var d_real_array_3d)
-             (Constructor (StdVector (StdVector (StdVector Double)))
+             (Constructor (StdVector (StdVector (StdVector (Double AoS) AoS) AoS) AoS)
               ((Var d_int)
-               (Constructor (StdVector (StdVector Double))
+               (Constructor (StdVector (StdVector (Double AoS) AoS) AoS)
                 ((Literal 2)
-                 (Constructor (StdVector Double)
+                 (Constructor (StdVector (Double AoS) AoS)
                   ((Literal 3) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_real_array_3d_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 254)))
              (Expression
@@ -16435,18 +17023,18 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_real_array_3d\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Literal 3)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Var d_int)) (Increment (Var sym3__))
                     (Block
                      ((Expression
@@ -16473,35 +17061,36 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_matrix\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_matrix_data__)
-             (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
               ((Var d_int) (Var d_int)
                (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
-            (OperatorNew d_matrix (TypeTrait Eigen::Map ((Matrix Double -1 -1 AoS)))
+            (OperatorNew d_matrix
+             (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 -1 AoS)))
              ((MethodCall (Var d_matrix_data__) data () ()) (Var d_int) (Var d_int))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__))) (name d_matrix_flat__)
-               (init Uninitialized)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+               (name d_matrix_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 257)))
              (Expression
               (Assign (Var d_matrix_flat__)
                (MethodCall (Var context__) vals_r () ((Literal "\"d_matrix\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var d_int)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var d_int)) (Increment (Var sym2__))
                  (Block
                   ((Expression
@@ -16531,21 +17120,21 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_matrix_array\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_matrix_array)
-             (Constructor (StdVector (Matrix Double -1 -1 AoS))
+             (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
               ((Var d_int)
-               (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+               (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                 ((Var d_int) (Var d_int)
                  (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_matrix_array_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 261)))
              (Expression
@@ -16553,18 +17142,18 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_matrix_array\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var d_int)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var d_int)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Var d_int)) (Increment (Var sym3__))
                     (Block
                      ((Expression
@@ -16595,24 +17184,24 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_matrix_array_2d\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_matrix_array_2d)
-             (Constructor (StdVector (StdVector (Matrix Double -1 -1 AoS)))
+             (Constructor (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS)
               ((Var d_int)
-               (Constructor (StdVector (Matrix Double -1 -1 AoS))
+               (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                 ((Literal 2)
-                 (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                 (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                   ((Var d_int) (Var d_int)
                    (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_matrix_array_2d_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 265)))
              (Expression
@@ -16620,22 +17209,22 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_matrix_array_2d\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var d_int)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var d_int)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Literal 2)) (Increment (Var sym3__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym4__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym4__) LEq (Var d_int)) (Increment (Var sym4__))
                        (Block
@@ -16669,27 +17258,30 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_matrix_array_3d\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_matrix_array_3d)
-             (Constructor (StdVector (StdVector (StdVector (Matrix Double -1 -1 AoS))))
+             (Constructor
+              (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS)
+               AoS)
               ((Var d_int)
-               (Constructor (StdVector (StdVector (Matrix Double -1 -1 AoS)))
+               (Constructor
+                (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS)
                 ((Literal 2)
-                 (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                 (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                   ((Literal 3)
-                   (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                   (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                     ((Var d_int) (Var d_int)
                      (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_matrix_array_3d_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 269)))
              (Expression
@@ -16697,27 +17289,27 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_matrix_array_3d\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var d_int)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var d_int)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Literal 3)) (Increment (Var sym3__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym4__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym4__) LEq (Literal 2)) (Increment (Var sym4__))
                        (Block
                         ((For
-                          ((static false) (constexpr false) (type_ Int) 
+                          ((static false) (constexpr false) (type_ (Int AoS))
                            (name sym5__) (init (Assignment (Literal 1))))
                           (BinOp (Var sym5__) LEq (Var d_int)) (Increment (Var sym5__))
                           (Block
@@ -16744,27 +17336,27 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_vector\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_vector_data__)
-             (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
               ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
-            (OperatorNew d_vector (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))
+            (OperatorNew d_vector (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS)))
              ((MethodCall (Var d_vector_data__) data () ()) (Var d_int))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__))) (name d_vector_flat__)
-               (init Uninitialized)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
+               (name d_vector_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 271)))
              (Expression
               (Assign (Var d_vector_flat__)
                (MethodCall (Var context__) vals_r () ((Literal "\"d_vector\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var d_int)) (Increment (Var sym1__))
               (Block
@@ -16790,19 +17382,19 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_vector_array\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_vector_array)
-             (Constructor (StdVector (Matrix Double -1 1 AoS))
+             (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
               ((Var d_int)
-               (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+               (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                 ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_vector_array_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 274)))
              (Expression
@@ -16810,13 +17402,13 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_vector_array\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var d_int)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var d_int)) (Increment (Var sym2__))
                  (Block
                   ((Expression
@@ -16842,22 +17434,22 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_vector_array_2d\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_vector_array_2d)
-             (Constructor (StdVector (StdVector (Matrix Double -1 1 AoS)))
+             (Constructor (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
               ((Var d_int)
-               (Constructor (StdVector (Matrix Double -1 1 AoS))
+               (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                 ((Literal 2)
-                 (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                 (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                   ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_vector_array_2d_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 277)))
              (Expression
@@ -16865,18 +17457,18 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_vector_array_2d\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var d_int)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Var d_int)) (Increment (Var sym3__))
                     (Block
                      ((Expression
@@ -16903,25 +17495,28 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_vector_array_3d\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_vector_array_3d)
-             (Constructor (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS))))
+             (Constructor
+              (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
+               AoS)
               ((Var d_int)
-               (Constructor (StdVector (StdVector (Matrix Double -1 1 AoS)))
+               (Constructor
+                (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
                 ((Literal 2)
-                 (Constructor (StdVector (Matrix Double -1 1 AoS))
+                 (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                   ((Literal 3)
-                   (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                   (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                     ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_vector_array_3d_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 280)))
              (Expression
@@ -16929,22 +17524,22 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_vector_array_3d\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var d_int)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Literal 2)) (Increment (Var sym3__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym4__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym4__) LEq (Var d_int)) (Increment (Var sym4__))
                        (Block
@@ -16970,19 +17565,20 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_row_vector\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_row_vector_data__)
-             (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
               ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
-            (OperatorNew d_row_vector (TypeTrait Eigen::Map ((Matrix Double 1 -1 AoS)))
+            (OperatorNew d_row_vector
+             (TypeTrait Eigen::Map ((Matrix (Double AoS) 1 -1 AoS)))
              ((MethodCall (Var d_row_vector_data__) data () ()) (Var d_int))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_row_vector_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 282)))
              (Expression
@@ -16990,7 +17586,7 @@
                (MethodCall (Var context__) vals_r () ((Literal "\"d_row_vector\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var d_int)) (Increment (Var sym1__))
               (Block
@@ -17016,19 +17612,19 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_row_vector_array\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_row_vector_array)
-             (Constructor (StdVector (Matrix Double 1 -1 AoS))
+             (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
               ((Var d_int)
-               (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+               (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                 ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_row_vector_array_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 285)))
              (Expression
@@ -17037,13 +17633,13 @@
                 ((Literal "\"d_row_vector_array\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var d_int)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Var d_int)) (Increment (Var sym2__))
                  (Block
                   ((Expression
@@ -17069,22 +17665,22 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_row_vector_array_2d\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_row_vector_array_2d)
-             (Constructor (StdVector (StdVector (Matrix Double 1 -1 AoS)))
+             (Constructor (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS)
               ((Var d_int)
-               (Constructor (StdVector (Matrix Double 1 -1 AoS))
+               (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
                 ((Literal 2)
-                 (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                 (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                   ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_row_vector_array_2d_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 288)))
              (Expression
@@ -17093,18 +17689,18 @@
                 ((Literal "\"d_row_vector_array_2d\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var d_int)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Literal 2)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Var d_int)) (Increment (Var sym3__))
                     (Block
                      ((Expression
@@ -17131,25 +17727,28 @@
             (MethodCall (Var context__) validate_dims ()
              ((Literal "\"data initialization\"") (Literal "\"d_row_vector_array_3d\"")
               (Literal "\"double\"")
-              (InitializerExpr (StdVector (TypeLiteral size_t))
-               ((FunCall static_cast ((TypeLiteral size_t)) ((Var d_int)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 2)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Literal 3)))
-                (FunCall static_cast ((TypeLiteral size_t)) ((Var d_int))))))))
+              (InitializerExpr (StdVector (TypeLiteral size_t AoS) AoS)
+               ((FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 2)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Literal 3)))
+                (FunCall static_cast ((TypeLiteral size_t AoS)) ((Var d_int))))))))
            (Expression
             (Assign (Var d_row_vector_array_3d)
-             (Constructor (StdVector (StdVector (StdVector (Matrix Double 1 -1 AoS))))
+             (Constructor
+              (StdVector (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS)
+               AoS)
               ((Var d_int)
-               (Constructor (StdVector (StdVector (Matrix Double 1 -1 AoS)))
+               (Constructor
+                (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS)
                 ((Literal 2)
-                 (Constructor (StdVector (Matrix Double 1 -1 AoS))
+                 (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
                   ((Literal 3)
-                   (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                   (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                     ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
            (Block
             ((VariableDefn
               ((static false) (constexpr false)
-               (type_ (StdVector (TypeLiteral local_scalar_t__)))
+               (type_ (StdVector (TypeLiteral local_scalar_t__ AoS) AoS))
                (name d_row_vector_array_3d_flat__) (init Uninitialized)))
              (Expression (Assign (Var current_statement__) (Literal 291)))
              (Expression
@@ -17158,22 +17757,22 @@
                 ((Literal "\"d_row_vector_array_3d\"")))))
              (Expression (Assign (Var pos__) (Literal 1)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq (Var d_int)) (Increment (Var sym1__))
               (Block
                ((For
-                 ((static false) (constexpr false) (type_ Int) (name sym2__)
-                  (init (Assignment (Literal 1))))
+                 ((static false) (constexpr false) (type_ (Int AoS)) 
+                  (name sym2__) (init (Assignment (Literal 1))))
                  (BinOp (Var sym2__) LEq (Literal 3)) (Increment (Var sym2__))
                  (Block
                   ((For
-                    ((static false) (constexpr false) (type_ Int) (name sym3__)
-                     (init (Assignment (Literal 1))))
+                    ((static false) (constexpr false) (type_ (Int AoS)) 
+                     (name sym3__) (init (Assignment (Literal 1))))
                     (BinOp (Var sym3__) LEq (Literal 2)) (Increment (Var sym3__))
                     (Block
                      ((For
-                       ((static false) (constexpr false) (type_ Int) 
+                       ((static false) (constexpr false) (type_ (Int AoS)) 
                         (name sym4__) (init (Assignment (Literal 1))))
                        (BinOp (Var sym4__) LEq (Var d_int)) (Increment (Var sym4__))
                        (Block
@@ -17200,7 +17799,7 @@
            (Expression (Assign (Var current_statement__) (Literal 294)))
            (Expression
             (Assign (Var td_1d)
-             (Constructor (StdVector Int)
+             (Constructor (StdVector (Int AoS) AoS)
               ((Var N) (FunCall std::numeric_limits<int>::min () ())))))
            (Expression (Assign (Var current_statement__) (Literal 295)))
            (Expression
@@ -17209,7 +17808,7 @@
            (Expression (Assign (Var current_statement__) (Literal 296)))
            (Expression
             (Assign (Var td_1dk)
-             (Constructor (StdVector Int)
+             (Constructor (StdVector (Int AoS) AoS)
               ((Var M) (FunCall std::numeric_limits<int>::min () ())))))
            (Expression (Assign (Var current_statement__) (Literal 296)))
            (Expression
@@ -17234,11 +17833,11 @@
            (Expression (Assign (Var current_statement__) (Literal 300)))
            (Expression
             (Assign (Var td_ar_mat)
-             (Constructor (StdVector (StdVector (Matrix Double -1 -1 AoS)))
+             (Constructor (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS)
               ((Literal 4)
-               (Constructor (StdVector (Matrix Double -1 -1 AoS))
+               (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                 ((Literal 5)
-                 (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                 (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                   ((Literal 2) (Literal 3)
                    (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
            (Expression (Assign (Var current_statement__) (Literal 301)))
@@ -17248,10 +17847,11 @@
            (Expression (Assign (Var current_statement__) (Literal 302)))
            (Expression
             (Assign (Var td_simplex_data__)
-             (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
               ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
-            (OperatorNew td_simplex (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))
+            (OperatorNew td_simplex
+             (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS)))
              ((MethodCall (Var td_simplex_data__) data () ()) (Var N))))
            (Expression (Assign (Var current_statement__) (Literal 303)))
            (Expression
@@ -17264,9 +17864,9 @@
            (Expression (Assign (Var current_statement__) (Literal 305)))
            (Expression
             (Assign (Var td_1d_simplex)
-             (Constructor (StdVector (Matrix Double -1 1 AoS))
+             (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
               ((Var N)
-               (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+               (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                 ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Expression (Assign (Var current_statement__) (Literal 306)))
            (Expression
@@ -17287,71 +17887,76 @@
            (Expression (Assign (Var current_statement__) (Literal 310)))
            (Expression
             (Assign (Var td_3d_simplex)
-             (Constructor (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS))))
+             (Constructor
+              (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
+               AoS)
               ((Var N)
-               (Constructor (StdVector (StdVector (Matrix Double -1 1 AoS)))
+               (Constructor
+                (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
                 ((Var M)
-                 (Constructor (StdVector (Matrix Double -1 1 AoS))
+                 (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                   ((Var K)
-                   (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                   (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                     ((Var N) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
            (Expression (Assign (Var current_statement__) (Literal 311)))
            (Expression
             (Assign (Var td_cfcov_54_data__)
-             (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
               ((Literal 5) (Literal 5)
                (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
-            (OperatorNew td_cfcov_54 (TypeTrait Eigen::Map ((Matrix Double -1 -1 AoS)))
+            (OperatorNew td_cfcov_54
+             (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 -1 AoS)))
              ((MethodCall (Var td_cfcov_54_data__) data () ()) (Literal 5) (Literal 5))))
            (Expression (Assign (Var current_statement__) (Literal 312)))
            (Expression
             (Assign (Var td_cfcov_33_data__)
-             (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
               ((Literal 3) (Literal 3)
                (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
-            (OperatorNew td_cfcov_33 (TypeTrait Eigen::Map ((Matrix Double -1 -1 AoS)))
+            (OperatorNew td_cfcov_33
+             (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 -1 AoS)))
              ((MethodCall (Var td_cfcov_33_data__) data () ()) (Literal 3) (Literal 3))))
            (Expression (Assign (Var current_statement__) (Literal 313)))
            (Expression
             (Assign (Var x_data__)
-             (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
               ((Literal 2) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
-            (OperatorNew x (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))
+            (OperatorNew x (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS)))
              ((MethodCall (Var x_data__) data () ()) (Literal 2))))
            (Expression (Assign (Var current_statement__) (Literal 314)))
            (Expression
             (Assign (Var y_data__)
-             (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
               ((Literal 2) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
-            (OperatorNew y (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))
+            (OperatorNew y (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS)))
              ((MethodCall (Var y_data__) data () ()) (Literal 2))))
            (Expression (Assign (Var current_statement__) (Literal 315)))
            (Expression
             (Assign (Var dat)
-             (Constructor (StdVector Double)
+             (Constructor (StdVector (Double AoS) AoS)
               ((Literal 0) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression (Assign (Var current_statement__) (Literal 316)))
            (Expression
             (Assign (Var dat_int)
-             (Constructor (StdVector Int)
+             (Constructor (StdVector (Int AoS) AoS)
               ((Literal 0) (FunCall std::numeric_limits<int>::min () ())))))
            (Expression (Assign (Var current_statement__) (Literal 317)))
            (Expression
             (Assign (Var x_r)
-             (Constructor (StdVector (StdVector Double))
+             (Constructor (StdVector (StdVector (Double AoS) AoS) AoS)
               ((Literal 0)
-               (Constructor (StdVector Double)
+               (Constructor (StdVector (Double AoS) AoS)
                 ((Literal 0) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Expression (Assign (Var current_statement__) (Literal 318)))
            (Expression
             (Assign (Var x_i)
-             (Constructor (StdVector (StdVector Int))
+             (Constructor (StdVector (StdVector (Int AoS) AoS) AoS)
               ((Literal 0)
-               (Constructor (StdVector Int)
+               (Constructor (StdVector (Int AoS) AoS)
                 ((Literal 0) (FunCall std::numeric_limits<int>::min () ())))))))
            (Expression (Assign (Var current_statement__) (Literal 319)))
            (Expression
@@ -17367,26 +17972,26 @@
                (FunCall stan::math::primitive_value () ((Literal 2)))))))
            (Expression (Assign (Var current_statement__) (Literal 329)))
            (For
-            ((static false) (constexpr false) (type_ Int) (name i)
+            ((static false) (constexpr false) (type_ (Int AoS)) (name i)
              (init (Assignment (Literal 1))))
             (BinOp (Var i) LEq (Literal 2)) (Increment (Var i))
             (Block
              ((Expression (Assign (Var current_statement__) (Literal 327)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name j)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name j)
                 (init (Assignment (Literal 1))))
                (BinOp (Var j) LEq (Literal 3)) (Increment (Var j))
                (Block
                 ((Expression (Assign (Var current_statement__) (Literal 325)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name m)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name m) (init (Assignment (Literal 1))))
                   (BinOp (Var m) LEq (Literal 4)) (Increment (Var m))
                   (Block
                    ((Expression (Assign (Var current_statement__) (Literal 323)))
                     (For
-                     ((static false) (constexpr false) (type_ Int) (name n)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name n) (init (Assignment (Literal 1))))
                      (BinOp (Var n) LEq (Literal 5)) (Increment (Var n))
                      (Block
                       ((Expression (Assign (Var current_statement__) (Literal 321)))
@@ -17400,7 +18005,7 @@
                           (FunCall stan::model::index_uni () ((Var j))))))))))))))))))
            (Expression (Assign (Var current_statement__) (Literal 340)))
            (For
-            ((static false) (constexpr false) (type_ Int) (name i)
+            ((static false) (constexpr false) (type_ (Int AoS)) (name i)
              (init (Assignment (Literal 1))))
             (BinOp (Var i) LEq (Var N)) (Increment (Var i))
             (Block
@@ -17412,7 +18017,7 @@
                  (FunCall stan::model::index_uni () ((Var i))))))
               (Expression (Assign (Var current_statement__) (Literal 338)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name n)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name n)
                 (init (Assignment (Literal 1))))
                (BinOp (Var n) LEq (Var N)) (Increment (Var n))
                (Block
@@ -17425,14 +18030,14 @@
                     (FunCall stan::model::index_uni () ((Var i))))))
                  (Expression (Assign (Var current_statement__) (Literal 336)))
                  (For
-                  ((static false) (constexpr false) (type_ Int) (name m)
-                   (init (Assignment (Literal 1))))
+                  ((static false) (constexpr false) (type_ (Int AoS)) 
+                   (name m) (init (Assignment (Literal 1))))
                   (BinOp (Var m) LEq (Var M)) (Increment (Var m))
                   (Block
                    ((Expression (Assign (Var current_statement__) (Literal 334)))
                     (For
-                     ((static false) (constexpr false) (type_ Int) (name k)
-                      (init (Assignment (Literal 1))))
+                     ((static false) (constexpr false) (type_ (Int AoS)) 
+                      (name k) (init (Assignment (Literal 1))))
                      (BinOp (Var k) LEq (Var K)) (Increment (Var k))
                      (Block
                       ((Expression (Assign (Var current_statement__) (Literal 332)))
@@ -17447,22 +18052,22 @@
                           (FunCall stan::model::index_uni () ((Var i))))))))))))))))))
            (Expression (Assign (Var current_statement__) (Literal 346)))
            (For
-            ((static false) (constexpr false) (type_ Int) (name i)
+            ((static false) (constexpr false) (type_ (Int AoS)) (name i)
              (init (Assignment (Literal 1))))
             (BinOp (Var i) LEq (Literal 4)) (Increment (Var i))
             (Block
              ((Expression (Assign (Var current_statement__) (Literal 344)))
               (For
-               ((static false) (constexpr false) (type_ Int) (name j)
+               ((static false) (constexpr false) (type_ (Int AoS)) (name j)
                 (init (Assignment (Literal 1))))
                (BinOp (Var j) LEq (Literal 5)) (Increment (Var j))
                (Block
                 ((VariableDefn
-                  ((static false) (constexpr false) (type_ (Matrix Double -1 -1 AoS))
-                   (name l_mat)
+                  ((static false) (constexpr false)
+                   (type_ (Matrix (Double AoS) -1 -1 AoS)) (name l_mat)
                    (init
                     (Assignment
-                     (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                     (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                       ((Literal 2) (Literal 3)
                        (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
                  (Expression (Assign (Var current_statement__) (Literal 341)))
@@ -17513,26 +18118,27 @@
               (Literal "\"assigning variable td_cfcov_33\""))))
            (Block
             ((VariableDefn
-              ((static false) (constexpr false) (type_ Double) (name z)
+              ((static false) (constexpr false) (type_ (Double AoS)) 
+               (name z)
                (init (Assignment (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
              (VariableDefn
-              ((static false) (constexpr false) (type_ (Matrix Double 1 -1 AoS))
+              ((static false) (constexpr false) (type_ (Matrix (Double AoS) 1 -1 AoS))
                (name blocked_tdata_vs)
                (init
                 (Assignment
-                 (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                 (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                   ((Literal 2) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
              (Expression (Assign (Var current_statement__) (Literal 351)))
              (For
-              ((static false) (constexpr false) (type_ Int) (name sym1__)
+              ((static false) (constexpr false) (type_ (Int AoS)) (name sym1__)
                (init (Assignment (Literal 1))))
               (BinOp (Var sym1__) LEq
                (FunCall stan::math::size () ((Var blocked_tdata_vs))))
               (Increment (Var sym1__))
               (Block
                ((VariableDefn
-                 ((static false) (constexpr false) (type_ Double) (name v)
-                  (init Uninitialized)))
+                 ((static false) (constexpr false) (type_ (Double AoS)) 
+                  (name v) (init Uninitialized)))
                 (Expression (Assign (Var current_statement__) (Literal 351)))
                 (Expression
                  (Assign (Var v)
@@ -17541,22 +18147,22 @@
                 (Expression (Assign (Var current_statement__) (Literal 352)))
                 (Expression (Assign (Var z) (Literal 0))))))
              (VariableDefn
-              ((static false) (constexpr false) (type_ (StdVector Int)) 
+              ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
                (name indices)
                (init
                 (Assignment
-                 (Constructor (StdVector Int)
+                 (Constructor (StdVector (Int AoS) AoS)
                   ((Literal 4) (FunCall std::numeric_limits<int>::min () ())))))))
              (Expression (Assign (Var current_statement__) (Literal 353)))
              (Expression
               (FunCall stan::model::assign ()
                ((Var indices)
-                (InitializerExpr (StdVector Int)
+                (InitializerExpr (StdVector (Int AoS) AoS)
                  ((Literal 1) (Literal 2) (Literal 3) (Literal 4)))
                 (Literal "\"assigning variable indices\""))))
              (Block
               ((VariableDefn
-                ((static false) (constexpr false) (type_ (StdVector Int)) 
+                ((static false) (constexpr false) (type_ (StdVector (Int AoS) AoS))
                  (name sym1__) (init Uninitialized)))
                (Expression (Assign (Var current_statement__) (Literal 354)))
                (Expression
@@ -17568,14 +18174,14 @@
                   (Literal "\"assigning variable sym1__\""))))
                (Expression (Assign (Var current_statement__) (Literal 355)))
                (For
-                ((static false) (constexpr false) (type_ Int) (name sym3__)
+                ((static false) (constexpr false) (type_ (Int AoS)) (name sym3__)
                  (init (Assignment (Literal 1))))
                 (BinOp (Var sym3__) LEq (FunCall stan::math::size () ((Var sym1__))))
                 (Increment (Var sym3__))
                 (Block
                  ((VariableDefn
-                   ((static false) (constexpr false) (type_ Int) (name i)
-                    (init Uninitialized)))
+                   ((static false) (constexpr false) (type_ (Int AoS)) 
+                    (name i) (init Uninitialized)))
                   (Expression (Assign (Var current_statement__) (Literal 355)))
                   (Expression
                    (Assign (Var i)
@@ -17622,28 +18228,28 @@
            (Expression (Assign (Var current_statement__) (Literal 362)))
            (Expression
             (Assign (Var arr_mul_ind)
-             (Constructor (StdVector (StdVector Int))
+             (Constructor (StdVector (StdVector (Int AoS) AoS) AoS)
               ((Literal 2)
-               (Constructor (StdVector Int)
+               (Constructor (StdVector (Int AoS) AoS)
                 ((Literal 2) (FunCall std::numeric_limits<int>::min () ())))))))
            (Expression (Assign (Var current_statement__) (Literal 363)))
            (Expression
             (FunCall stan::model::assign ()
              ((Var arr_mul_ind)
-              (InitializerExpr (StdVector Int) ((Literal 1) (Literal 1)))
+              (InitializerExpr (StdVector (Int AoS) AoS) ((Literal 1) (Literal 1)))
               (Literal "\"assigning variable arr_mul_ind\"")
               (FunCall stan::model::index_uni () ((Literal 1)))
               (FunCall stan::model::index_min_max () ((Literal 1) (Literal 2))))))
            (Expression (Assign (Var current_statement__) (Literal 364)))
            (Expression
             (Assign (Var x_mul_ind)
-             (Constructor (StdVector Double)
+             (Constructor (StdVector (Double AoS) AoS)
               ((Literal 2) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression (Assign (Var current_statement__) (Literal 364)))
            (Expression
             (FunCall stan::model::assign ()
              ((Var x_mul_ind)
-              (InitializerExpr (StdVector Double) ((Literal 1) (Literal 2)))
+              (InitializerExpr (StdVector (Double AoS) AoS) ((Literal 1) (Literal 2)))
               (Literal "\"assigning variable x_mul_ind\""))))
            (Expression (Assign (Var current_statement__) (Literal 365)))
            (Expression
@@ -17657,7 +18263,7 @@
            (Expression (Assign (Var current_statement__) (Literal 367)))
            (Expression
             (Assign (Var transformed_data_real_array)
-             (Constructor (StdVector Double)
+             (Constructor (StdVector (Double AoS) AoS)
               ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression (Assign (Var current_statement__) (Literal 368)))
            (Expression
@@ -17667,9 +18273,9 @@
            (Expression (Assign (Var current_statement__) (Literal 369)))
            (Expression
             (Assign (Var transformed_data_real_array_2d)
-             (Constructor (StdVector (StdVector Double))
+             (Constructor (StdVector (StdVector (Double AoS) AoS) AoS)
               ((Var d_int)
-               (Constructor (StdVector Double)
+               (Constructor (StdVector (Double AoS) AoS)
                 ((Literal 2) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Expression (Assign (Var current_statement__) (Literal 370)))
            (Expression
@@ -17679,11 +18285,11 @@
            (Expression (Assign (Var current_statement__) (Literal 371)))
            (Expression
             (Assign (Var transformed_data_real_array_3d)
-             (Constructor (StdVector (StdVector (StdVector Double)))
+             (Constructor (StdVector (StdVector (StdVector (Double AoS) AoS) AoS) AoS)
               ((Var d_int)
-               (Constructor (StdVector (StdVector Double))
+               (Constructor (StdVector (StdVector (Double AoS) AoS) AoS)
                 ((Literal 2)
-                 (Constructor (StdVector Double)
+                 (Constructor (StdVector (Double AoS) AoS)
                   ((Literal 3) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
            (Expression (Assign (Var current_statement__) (Literal 372)))
            (Expression
@@ -17696,12 +18302,12 @@
            (Expression (Assign (Var current_statement__) (Literal 374)))
            (Expression
             (Assign (Var transformed_data_matrix_data__)
-             (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
               ((Var d_int) (Var d_int)
                (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
             (OperatorNew transformed_data_matrix
-             (TypeTrait Eigen::Map ((Matrix Double -1 -1 AoS)))
+             (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 -1 AoS)))
              ((MethodCall (Var transformed_data_matrix_data__) data () ()) 
               (Var d_int) (Var d_int))))
            (Expression (Assign (Var current_statement__) (Literal 375)))
@@ -17722,9 +18328,9 @@
            (Expression (Assign (Var current_statement__) (Literal 378)))
            (Expression
             (Assign (Var transformed_data_matrix_array)
-             (Constructor (StdVector (Matrix Double -1 -1 AoS))
+             (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
               ((Var d_int)
-               (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+               (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                 ((Var d_int) (Var d_int)
                  (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Expression (Assign (Var current_statement__) (Literal 379)))
@@ -17745,11 +18351,11 @@
            (Expression (Assign (Var current_statement__) (Literal 382)))
            (Expression
             (Assign (Var transformed_data_matrix_array_2d)
-             (Constructor (StdVector (StdVector (Matrix Double -1 -1 AoS)))
+             (Constructor (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS)
               ((Var d_int)
-               (Constructor (StdVector (Matrix Double -1 -1 AoS))
+               (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                 ((Literal 2)
-                 (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                 (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                   ((Var d_int) (Var d_int)
                    (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
            (Expression (Assign (Var current_statement__) (Literal 383)))
@@ -17770,13 +18376,16 @@
            (Expression (Assign (Var current_statement__) (Literal 386)))
            (Expression
             (Assign (Var transformed_data_matrix_array_3d)
-             (Constructor (StdVector (StdVector (StdVector (Matrix Double -1 -1 AoS))))
+             (Constructor
+              (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS)
+               AoS)
               ((Var d_int)
-               (Constructor (StdVector (StdVector (Matrix Double -1 -1 AoS)))
+               (Constructor
+                (StdVector (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS) AoS)
                 ((Literal 2)
-                 (Constructor (StdVector (Matrix Double -1 -1 AoS))
+                 (Constructor (StdVector (Matrix (Double AoS) -1 -1 AoS) AoS)
                   ((Literal 3)
-                   (StaticMethodCall (Matrix Double -1 -1 AoS) Constant ()
+                   (StaticMethodCall (Matrix (Double AoS) -1 -1 AoS) Constant ()
                     ((Var d_int) (Var d_int)
                      (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
            (Expression (Assign (Var current_statement__) (Literal 387)))
@@ -17786,11 +18395,11 @@
            (Expression (Assign (Var current_statement__) (Literal 388)))
            (Expression
             (Assign (Var transformed_data_vector_data__)
-             (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
               ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
             (OperatorNew transformed_data_vector
-             (TypeTrait Eigen::Map ((Matrix Double -1 1 AoS)))
+             (TypeTrait Eigen::Map ((Matrix (Double AoS) -1 1 AoS)))
              ((MethodCall (Var transformed_data_vector_data__) data () ()) (Var d_int))))
            (Expression (Assign (Var current_statement__) (Literal 389)))
            (Expression
@@ -17805,9 +18414,9 @@
            (Expression (Assign (Var current_statement__) (Literal 391)))
            (Expression
             (Assign (Var transformed_data_vector_array)
-             (Constructor (StdVector (Matrix Double -1 1 AoS))
+             (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
               ((Var d_int)
-               (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+               (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                 ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Expression (Assign (Var current_statement__) (Literal 392)))
            (Expression
@@ -17822,11 +18431,11 @@
            (Expression (Assign (Var current_statement__) (Literal 394)))
            (Expression
             (Assign (Var transformed_data_vector_array_2d)
-             (Constructor (StdVector (StdVector (Matrix Double -1 1 AoS)))
+             (Constructor (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
               ((Var d_int)
-               (Constructor (StdVector (Matrix Double -1 1 AoS))
+               (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                 ((Literal 2)
-                 (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                 (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                   ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
            (Expression (Assign (Var current_statement__) (Literal 395)))
            (Expression
@@ -17841,13 +18450,16 @@
            (Expression (Assign (Var current_statement__) (Literal 397)))
            (Expression
             (Assign (Var transformed_data_vector_array_3d)
-             (Constructor (StdVector (StdVector (StdVector (Matrix Double -1 1 AoS))))
+             (Constructor
+              (StdVector (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
+               AoS)
               ((Var d_int)
-               (Constructor (StdVector (StdVector (Matrix Double -1 1 AoS)))
+               (Constructor
+                (StdVector (StdVector (Matrix (Double AoS) -1 1 AoS) AoS) AoS)
                 ((Literal 2)
-                 (Constructor (StdVector (Matrix Double -1 1 AoS))
+                 (Constructor (StdVector (Matrix (Double AoS) -1 1 AoS) AoS)
                   ((Literal 3)
-                   (StaticMethodCall (Matrix Double -1 1 AoS) Constant ()
+                   (StaticMethodCall (Matrix (Double AoS) -1 1 AoS) Constant ()
                     ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
            (Expression (Assign (Var current_statement__) (Literal 398)))
            (Expression
@@ -17857,11 +18469,11 @@
            (Expression (Assign (Var current_statement__) (Literal 399)))
            (Expression
             (Assign (Var transformed_data_row_vector_data__)
-             (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+             (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
               ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))
            (Expression
             (OperatorNew transformed_data_row_vector
-             (TypeTrait Eigen::Map ((Matrix Double 1 -1 AoS)))
+             (TypeTrait Eigen::Map ((Matrix (Double AoS) 1 -1 AoS)))
              ((MethodCall (Var transformed_data_row_vector_data__) data () ())
               (Var d_int))))
            (Expression (Assign (Var current_statement__) (Literal 400)))
@@ -17877,9 +18489,9 @@
            (Expression (Assign (Var current_statement__) (Literal 402)))
            (Expression
             (Assign (Var transformed_data_row_vector_array)
-             (Constructor (StdVector (Matrix Double 1 -1 AoS))
+             (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
               ((Var d_int)
-               (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+               (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                 ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))
            (Expression (Assign (Var current_statement__) (Literal 403)))
            (Expression
@@ -17894,11 +18506,11 @@
            (Expression (Assign (Var current_statement__) (Literal 405)))
            (Expression
             (Assign (Var transformed_data_row_vector_array_2d)
-             (Constructor (StdVector (StdVector (Matrix Double 1 -1 AoS)))
+             (Constructor (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS)
               ((Var d_int)
-               (Constructor (StdVector (Matrix Double 1 -1 AoS))
+               (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
                 ((Literal 2)
-                 (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                 (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                   ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))
            (Expression (Assign (Var current_statement__) (Literal 406)))
            (Expression
@@ -17913,13 +18525,16 @@
            (Expression (Assign (Var current_statement__) (Literal 408)))
            (Expression
             (Assign (Var transformed_data_row_vector_array_3d)
-             (Constructor (StdVector (StdVector (StdVector (Matrix Double 1 -1 AoS))))
+             (Constructor
+              (StdVector (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS)
+               AoS)
               ((Var d_int)
-               (Constructor (StdVector (StdVector (Matrix Double 1 -1 AoS)))
+               (Constructor
+                (StdVector (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS) AoS)
                 ((Literal 2)
-                 (Constructor (StdVector (Matrix Double 1 -1 AoS))
+                 (Constructor (StdVector (Matrix (Double AoS) 1 -1 AoS) AoS)
                   ((Literal 3)
-                   (StaticMethodCall (Matrix Double 1 -1 AoS) Constant ()
+                   (StaticMethodCall (Matrix (Double AoS) 1 -1 AoS) Constant ()
                     ((Var d_int) (FunCall std::numeric_limits<double>::quiet_NaN () ())))))))))))
            (Expression (Assign (Var current_statement__) (Literal 409)))
            (Expression
@@ -18891,7 +19506,7 @@
            (Expression
             (FunCall stan::math::validate_non_negative_index ()
              ((Literal "\"gq_cfcov_33_ar\"") (Literal "\"K\"") (Var K)))))
-          ((Const (Ref (TypeLiteral std::exception))) e)
+          ((Const (Ref (TypeLiteral std::exception AoS))) e)
           ((Expression
             (FunCall stan::lang::rethrow_located ()
              ((Var e) (Index (Var locations_array__) (Var current_statement__)))))))
@@ -19016,30 +19631,30 @@
              Add (Literal 2))
             Add (Literal 2))))))))
      (destructor_body ())))))
- (GlobalUsing stan_model ((TypeLiteral mother_model_namespace::mother_model)))
+ (GlobalUsing stan_model ((TypeLiteral mother_model_namespace::mother_model AoS)))
  (Preprocessor
   (IfNDef USING_R
    ((GlobalComment Boilerplate)
     (FunDef
      ((templates_init ((()) false)) (inline false)
-      (return_type (Ref (TypeLiteral stan::model::model_base))) (name new_model)
+      (return_type (Ref (TypeLiteral stan::model::model_base AoS))) (name new_model)
       (args
-       (((Ref (TypeLiteral stan::io::var_context)) data_context)
-        ((TypeLiteral "unsigned int") seed)
-        ((Pointer (TypeLiteral std::ostream)) msg_stream)))
+       (((Ref (TypeLiteral stan::io::var_context AoS)) data_context)
+        ((TypeLiteral "unsigned int" AoS) seed)
+        ((Pointer (TypeLiteral std::ostream AoS)) msg_stream)))
       (cv_qualifiers ())
       (body
        (((VariableDefn
-          ((static false) (constexpr false) (type_ (Pointer (TypeLiteral stan_model)))
-           (name m)
+          ((static false) (constexpr false)
+           (type_ (Pointer (TypeLiteral stan_model AoS))) (name m)
            (init
             (Assignment
-             (AllocNew (TypeLiteral stan_model)
+             (AllocNew (TypeLiteral stan_model AoS)
               ((Var data_context) (Var seed) (Var msg_stream)))))))
          (Return ((Literal *m))))))))
     (FunDef
      ((templates_init ((()) false)) (inline false)
-      (return_type (Ref (TypeLiteral stan::math::profile_map)))
+      (return_type (Ref (TypeLiteral stan::math::profile_map AoS)))
       (name get_stan_profile_data) (args ()) (cv_qualifiers ())
       (body (((Return ((Literal mother_model_namespace::profiles__)))))))))))
  (Preprocessor
diff --git a/test/integration/good/code-gen/mir.expected b/test/integration/good/code-gen/mir.expected
index 6a27e3c6e..369b97ef3 100644
--- a/test/integration/good/code-gen/mir.expected
+++ b/test/integration/good/code-gen/mir.expected
@@ -53,7 +53,7 @@
             (Decl (decl_adtype AutoDiffable) (decl_id dydt)
              (decl_type
               (Sized
-               (SArray SReal
+               (SArray AoS (SReal AoS)
                 ((pattern (Lit Int 2))
                  (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
              (initialize true)))
@@ -333,8 +333,8 @@
              ((pattern
                (Block
                 (((pattern
-                   (Decl (decl_adtype AutoDiffable) (decl_id b) (decl_type (Sized SInt))
-                    (initialize true)))
+                   (Decl (decl_adtype AutoDiffable) (decl_id b)
+                    (decl_type (Sized (SInt AoS))) (initialize true)))
                   (meta <opaque>))
                  ((pattern
                    (Assignment ((LVariable b) ()) UInt
@@ -406,8 +406,8 @@
                    (Decl (decl_adtype AutoDiffable) (decl_id vs)
                     (decl_type
                      (Sized
-                      (SArray
-                       (SArray SInt
+                      (SArray AoS
+                       (SArray AoS (SInt AoS)
                         ((pattern (Lit Int 3))
                          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
                        ((pattern (Lit Int 2))
@@ -415,8 +415,8 @@
                     (initialize true)))
                   (meta <opaque>))
                  ((pattern
-                   (Decl (decl_adtype AutoDiffable) (decl_id z) (decl_type (Sized SInt))
-                    (initialize true)))
+                   (Decl (decl_adtype AutoDiffable) (decl_id z)
+                    (decl_type (Sized (SInt AoS))) (initialize true)))
                   (meta <opaque>))
                  ((pattern
                    (For (loopvar sym1__)
@@ -618,8 +618,8 @@
              ((pattern
                (Block
                 (((pattern
-                   (Decl (decl_adtype AutoDiffable) (decl_id z) (decl_type (Sized SReal))
-                    (initialize true)))
+                   (Decl (decl_adtype AutoDiffable) (decl_id z)
+                    (decl_type (Sized (SReal AoS))) (initialize true)))
                   (meta <opaque>))
                  ((pattern
                    (Decl (decl_adtype AutoDiffable) (decl_id vs)
@@ -809,8 +809,8 @@
              ((pattern
                (Block
                 (((pattern
-                   (Decl (decl_adtype AutoDiffable) (decl_id z) (decl_type (Sized SReal))
-                    (initialize true)))
+                   (Decl (decl_adtype AutoDiffable) (decl_id z)
+                    (decl_type (Sized (SReal AoS))) (initialize true)))
                   (meta <opaque>))
                  ((pattern
                    (Decl (decl_adtype AutoDiffable) (decl_id vs)
@@ -925,8 +925,8 @@
              ((pattern
                (Block
                 (((pattern
-                   (Decl (decl_adtype AutoDiffable) (decl_id z) (decl_type (Sized SReal))
-                    (initialize true)))
+                   (Decl (decl_adtype AutoDiffable) (decl_id z)
+                    (decl_type (Sized (SReal AoS))) (initialize true)))
                   (meta <opaque>))
                  ((pattern
                    (Decl (decl_adtype AutoDiffable) (decl_id vs)
@@ -1043,8 +1043,8 @@
              ((pattern
                (Block
                 (((pattern
-                   (Decl (decl_adtype AutoDiffable) (decl_id b) (decl_type (Sized SInt))
-                    (initialize true)))
+                   (Decl (decl_adtype AutoDiffable) (decl_id b)
+                    (decl_type (Sized (SInt AoS))) (initialize true)))
                   (meta <opaque>))
                  ((pattern
                    (Assignment ((LVariable b) ()) UInt
@@ -1055,7 +1055,7 @@
                    (Block
                     (((pattern
                        (Decl (decl_adtype AutoDiffable) (decl_id c)
-                        (decl_type (Sized SInt)) (initialize true)))
+                        (decl_type (Sized (SInt AoS))) (initialize true)))
                       (meta <opaque>))
                      ((pattern
                        (Assignment ((LVariable c) ()) UInt
@@ -1082,13 +1082,13 @@
             (Decl (decl_adtype AutoDiffable) (decl_id vs)
              (decl_type
               (Sized
-               (SArray SInt
+               (SArray AoS (SInt AoS)
                 ((pattern (Lit Int 2))
                  (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
              (initialize true)))
            (meta <opaque>))
           ((pattern
-            (Decl (decl_adtype AutoDiffable) (decl_id y) (decl_type (Sized SInt))
+            (Decl (decl_adtype AutoDiffable) (decl_id y) (decl_type (Sized (SInt AoS)))
              (initialize true)))
            (meta <opaque>))
           ((pattern
@@ -1204,12 +1204,12 @@
      (((pattern
         (Block
          (((pattern
-            (Decl (decl_adtype AutoDiffable) (decl_id abs_diff) (decl_type (Sized SReal))
-             (initialize true)))
+            (Decl (decl_adtype AutoDiffable) (decl_id abs_diff)
+             (decl_type (Sized (SReal AoS))) (initialize true)))
            (meta <opaque>))
           ((pattern
             (Decl (decl_adtype AutoDiffable) (decl_id avg_scale)
-             (decl_type (Sized SReal)) (initialize true)))
+             (decl_type (Sized (SReal AoS))) (initialize true)))
            (meta <opaque>))
           ((pattern
             (Assignment ((LVariable abs_diff) ()) UReal
@@ -1727,19 +1727,19 @@
      (((pattern
         (Block
          (((pattern
-            (Decl (decl_adtype AutoDiffable) (decl_id a) (decl_type (Sized SInt))
+            (Decl (decl_adtype AutoDiffable) (decl_id a) (decl_type (Sized (SInt AoS)))
              (initialize true)))
            (meta <opaque>))
           ((pattern
-            (Decl (decl_adtype AutoDiffable) (decl_id b) (decl_type (Sized SReal))
+            (Decl (decl_adtype AutoDiffable) (decl_id b) (decl_type (Sized (SReal AoS)))
              (initialize true)))
            (meta <opaque>))
           ((pattern
             (Decl (decl_adtype AutoDiffable) (decl_id c)
              (decl_type
               (Sized
-               (SArray
-                (SArray SReal
+               (SArray AoS
+                (SArray AoS (SReal AoS)
                  ((pattern (Lit Int 30))
                   (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
                 ((pattern (Lit Int 20))
@@ -1750,8 +1750,8 @@
             (Decl (decl_adtype AutoDiffable) (decl_id ar_mat)
              (decl_type
               (Sized
-               (SArray
-                (SArray
+               (SArray AoS
+                (SArray AoS
                  (SMatrix AoS
                   ((pattern (Lit Int 40))
                    (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -2441,44 +2441,44 @@
   ((N
     ((begin_loc ((filename mother.stan) (line_num 348) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 348) (col_num 17) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (M
     ((begin_loc ((filename mother.stan) (line_num 349) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 349) (col_num 17) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (K
     ((begin_loc ((filename mother.stan) (line_num 350) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 350) (col_num 30) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (d_int_1d_ar
     ((begin_loc ((filename mother.stan) (line_num 351) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 351) (col_num 36) (included_from ()))))
-    (SArray SInt
+    (SArray AoS (SInt AoS)
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_int_3d_ar
     ((begin_loc ((filename mother.stan) (line_num 352) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 352) (col_num 42) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray SInt
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS (SInt AoS)
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
       ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (J
     ((begin_loc ((filename mother.stan) (line_num 353) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 353) (col_num 32) (included_from ()))))
-    SReal)
+    (SReal AoS))
    (d_real_1d_ar
     ((begin_loc ((filename mother.stan) (line_num 354) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 354) (col_num 29) (included_from ()))))
-    (SArray SReal
+    (SArray AoS (SReal AoS)
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_real_3d_ar
     ((begin_loc ((filename mother.stan) (line_num 355) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 355) (col_num 35) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray SReal
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS (SReal AoS)
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
       ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -2490,16 +2490,16 @@
    (d_1d_vec
     ((begin_loc ((filename mother.stan) (line_num 357) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 357) (col_num 30) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SVector AoS
       ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_3d_vec
     ((begin_loc ((filename mother.stan) (line_num 358) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 358) (col_num 36) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2513,16 +2513,16 @@
    (d_1d_row_vec
     ((begin_loc ((filename mother.stan) (line_num 360) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 360) (col_num 38) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SRowVector AoS
       ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_3d_row_vec
     ((begin_loc ((filename mother.stan) (line_num 361) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 361) (col_num 44) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2531,8 +2531,8 @@
    (d_ar_mat
     ((begin_loc ((filename mother.stan) (line_num 362) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 362) (col_num 54) (included_from ()))))
-    (SArray
-     (SArray
+    (SArray AoS
+     (SArray AoS
       (SMatrix AoS
        ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2546,16 +2546,16 @@
    (d_1d_simplex
     ((begin_loc ((filename mother.stan) (line_num 364) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 364) (col_num 35) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SVector AoS
       ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_3d_simplex
     ((begin_loc ((filename mother.stan) (line_num 365) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 365) (col_num 41) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2576,7 +2576,7 @@
    (d_cfcov_33_ar
     ((begin_loc ((filename mother.stan) (line_num 368) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 368) (col_num 48) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SMatrix AoS
       ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
       ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2584,50 +2584,50 @@
    (d_int
     ((begin_loc ((filename mother.stan) (line_num 369) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 369) (col_num 12) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (d_int_array
     ((begin_loc ((filename mother.stan) (line_num 370) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 370) (col_num 31) (included_from ()))))
-    (SArray SInt
+    (SArray AoS (SInt AoS)
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_int_array_2d
     ((begin_loc ((filename mother.stan) (line_num 371) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 371) (col_num 37) (included_from ()))))
-    (SArray
-     (SArray SInt
+    (SArray AoS
+     (SArray AoS (SInt AoS)
       ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_int_array_3d
     ((begin_loc ((filename mother.stan) (line_num 372) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 372) (col_num 40) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray SInt
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS (SInt AoS)
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
       ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_real
     ((begin_loc ((filename mother.stan) (line_num 373) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 373) (col_num 14) (included_from ()))))
-    SReal)
+    (SReal AoS))
    (d_real_array
     ((begin_loc ((filename mother.stan) (line_num 374) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 374) (col_num 33) (included_from ()))))
-    (SArray SReal
+    (SArray AoS (SReal AoS)
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_real_array_2d
     ((begin_loc ((filename mother.stan) (line_num 375) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 375) (col_num 39) (included_from ()))))
-    (SArray
-     (SArray SReal
+    (SArray AoS
+     (SArray AoS (SReal AoS)
       ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_real_array_3d
     ((begin_loc ((filename mother.stan) (line_num 376) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 376) (col_num 42) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray SReal
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
       ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -2640,7 +2640,7 @@
    (d_matrix_array
     ((begin_loc ((filename mother.stan) (line_num 378) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 378) (col_num 51) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SMatrix AoS
       ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
       ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2648,8 +2648,8 @@
    (d_matrix_array_2d
     ((begin_loc ((filename mother.stan) (line_num 379) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 379) (col_num 57) (included_from ()))))
-    (SArray
-     (SArray
+    (SArray AoS
+     (SArray AoS
       (SMatrix AoS
        ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
        ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2658,9 +2658,9 @@
    (d_matrix_array_3d
     ((begin_loc ((filename mother.stan) (line_num 380) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 380) (col_num 60) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2675,15 +2675,15 @@
    (d_vector_array
     ((begin_loc ((filename mother.stan) (line_num 382) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 382) (col_num 44) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SVector AoS
       ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_vector_array_2d
     ((begin_loc ((filename mother.stan) (line_num 383) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 383) (col_num 50) (included_from ()))))
-    (SArray
-     (SArray
+    (SArray AoS
+     (SArray AoS
       (SVector AoS
        ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
       ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2691,9 +2691,9 @@
    (d_vector_array_3d
     ((begin_loc ((filename mother.stan) (line_num 384) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 384) (col_num 53) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS
        (SVector AoS
         ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2707,15 +2707,15 @@
    (d_row_vector_array
     ((begin_loc ((filename mother.stan) (line_num 386) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 386) (col_num 52) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SRowVector AoS
       ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_row_vector_array_2d
     ((begin_loc ((filename mother.stan) (line_num 387) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 387) (col_num 58) (included_from ()))))
-    (SArray
-     (SArray
+    (SArray AoS
+     (SArray AoS
       (SRowVector AoS
        ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
       ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2723,9 +2723,9 @@
    (d_row_vector_array_3d
     ((begin_loc ((filename mother.stan) (line_num 388) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 388) (col_num 61) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2733,7 +2733,8 @@
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (NRFunApp
@@ -2747,7 +2748,8 @@
       (((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id M) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id M) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (NRFunApp
@@ -2761,7 +2763,8 @@
       (((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id K) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id K) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (NRFunApp
@@ -2804,7 +2807,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_int_1d_ar)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -2846,9 +2849,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_int_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SInt
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SInt AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -2869,7 +2872,7 @@
       (((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id J) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id J) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -2917,7 +2920,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -2946,9 +2949,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -2987,7 +2990,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -3025,9 +3028,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -3068,7 +3071,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -3106,9 +3109,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -3120,8 +3123,8 @@
      (Decl (decl_adtype DataOnly) (decl_id d_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -3199,7 +3202,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -3246,9 +3249,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -3313,7 +3316,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -3330,7 +3333,7 @@
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id d_int) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id d_int) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3345,7 +3348,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_int_array)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -3361,8 +3364,8 @@
      (Decl (decl_adtype DataOnly) (decl_id d_int_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray SInt
+        (SArray AoS
+         (SArray AoS (SInt AoS)
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -3379,9 +3382,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_int_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SInt
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SInt AoS)
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -3389,7 +3392,7 @@
       (initialize true)))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id d_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id d_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3404,7 +3407,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_real_array)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -3420,8 +3423,8 @@
      (Decl (decl_adtype DataOnly) (decl_id d_real_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray SReal
+        (SArray AoS
+         (SArray AoS (SReal AoS)
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -3438,9 +3441,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_real_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -3500,7 +3503,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_matrix_array)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -3535,8 +3538,8 @@
      (Decl (decl_adtype DataOnly) (decl_id d_matrix_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Var d_int))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -3574,9 +3577,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_matrix_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SMatrix AoS
             ((pattern (Var d_int))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -3624,7 +3627,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_vector_array)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -3650,8 +3653,8 @@
      (Decl (decl_adtype DataOnly) (decl_id d_vector_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SVector AoS
            ((pattern (Var d_int))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -3679,9 +3682,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_vector_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var d_int))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -3727,7 +3730,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_row_vector_array)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -3753,8 +3756,8 @@
      (Decl (decl_adtype DataOnly) (decl_id d_row_vector_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SRowVector AoS
            ((pattern (Var d_int))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -3782,9 +3785,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_row_vector_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var d_int))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -3795,7 +3798,7 @@
       (initialize true)))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id td_int) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id td_int) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3809,7 +3812,7 @@
      (Decl (decl_adtype DataOnly) (decl_id td_1d)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -3824,7 +3827,7 @@
      (Decl (decl_adtype DataOnly) (decl_id td_1dk)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -3837,7 +3840,7 @@
        (meta ((type_ (UArray UInt)) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id td_a) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id td_a) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3845,7 +3848,7 @@
       ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id td_b) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id td_b) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3861,7 +3864,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id td_c) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id td_c) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3875,8 +3878,8 @@
      (Decl (decl_adtype DataOnly) (decl_id td_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -3919,7 +3922,7 @@
      (Decl (decl_adtype DataOnly) (decl_id td_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -3957,9 +3960,9 @@
      (Decl (decl_adtype DataOnly) (decl_id td_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -4005,7 +4008,7 @@
      (Decl (decl_adtype DataOnly) (decl_id dat)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -4013,7 +4016,7 @@
      (Decl (decl_adtype DataOnly) (decl_id dat_int)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -4021,8 +4024,8 @@
      (Decl (decl_adtype DataOnly) (decl_id x_r)
       (decl_type
        (Sized
-        (SArray
-         (SArray SReal
+        (SArray AoS
+         (SArray AoS (SReal AoS)
           ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -4031,8 +4034,8 @@
      (Decl (decl_adtype DataOnly) (decl_id x_i)
       (decl_type
        (Sized
-        (SArray
-         (SArray SInt
+        (SArray AoS
+         (SArray AoS (SInt AoS)
           ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -4373,7 +4376,7 @@
    ((pattern
      (Block
       (((pattern
-         (Decl (decl_adtype DataOnly) (decl_id z) (decl_type (Sized SReal))
+         (Decl (decl_adtype DataOnly) (decl_id z) (decl_type (Sized (SReal AoS)))
           (initialize true)))
         (meta <opaque>))
        ((pattern
@@ -4432,7 +4435,7 @@
          (Decl (decl_adtype DataOnly) (decl_id indices)
           (decl_type
            (Sized
-            (SArray SInt
+            (SArray AoS (SInt AoS)
              ((pattern (Lit Int 4))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
           (initialize true)))
@@ -4570,8 +4573,8 @@
      (Decl (decl_adtype DataOnly) (decl_id arr_mul_ind)
       (decl_type
        (Sized
-        (SArray
-         (SArray SInt
+        (SArray AoS
+         (SArray AoS (SInt AoS)
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -4595,7 +4598,7 @@
      (Decl (decl_adtype DataOnly) (decl_id x_mul_ind)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -4619,7 +4622,7 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_real)
-      (decl_type (Sized SReal)) (initialize true)))
+      (decl_type (Sized (SReal AoS))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (NRFunApp (CompilerInternal FnValidateSize)
@@ -4633,7 +4636,7 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_real_array)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -4649,8 +4652,8 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_real_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray SReal
+        (SArray AoS
+         (SArray AoS (SReal AoS)
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -4667,9 +4670,9 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_real_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -4729,7 +4732,7 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_matrix_array)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -4764,8 +4767,8 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_matrix_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Var d_int))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -4803,9 +4806,9 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_matrix_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SMatrix AoS
             ((pattern (Var d_int))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -4853,7 +4856,7 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_vector_array)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -4879,8 +4882,8 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_vector_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SVector AoS
            ((pattern (Var d_int))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -4908,9 +4911,9 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_vector_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var d_int))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -4956,7 +4959,7 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_row_vector_array)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -4982,8 +4985,8 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_row_vector_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SRowVector AoS
            ((pattern (Var d_int))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -5011,9 +5014,9 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_row_vector_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var d_int))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -6791,22 +6794,22 @@
     (meta <opaque>))))
  (log_prob
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_upper) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_upper) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_lower) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_lower) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype AutoDiffable) (decl_id offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -6814,7 +6817,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id no_offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -6822,7 +6825,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id offset_no_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -6830,7 +6833,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -6838,9 +6841,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -6858,7 +6861,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -6868,9 +6871,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -6890,7 +6893,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -6900,9 +6903,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -6923,8 +6926,8 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -6946,7 +6949,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -6956,9 +6959,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -6988,7 +6991,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -7015,7 +7018,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -7023,9 +7026,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -7043,7 +7046,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -7053,9 +7056,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -7075,7 +7078,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -7085,9 +7088,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -7108,8 +7111,8 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -7131,7 +7134,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -7141,9 +7144,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -7173,7 +7176,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -7189,7 +7192,7 @@
       (initialize true)))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id tp_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id tp_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -7757,7 +7760,7 @@
          (Decl (decl_adtype AutoDiffable) (decl_id tmp2)
           (decl_type
            (Sized
-            (SArray
+            (SArray AoS
              (SVector AoS
               ((pattern (Lit Int 0))
                (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -7766,7 +7769,7 @@
           (initialize true)))
         (meta <opaque>))
        ((pattern
-         (Decl (decl_adtype AutoDiffable) (decl_id r1) (decl_type (Sized SReal))
+         (Decl (decl_adtype AutoDiffable) (decl_id r1) (decl_type (Sized (SReal AoS)))
           (initialize true)))
         (meta <opaque>))
        ((pattern
@@ -7778,7 +7781,7 @@
            (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
         (meta <opaque>))
        ((pattern
-         (Decl (decl_adtype AutoDiffable) (decl_id r2) (decl_type (Sized SReal))
+         (Decl (decl_adtype AutoDiffable) (decl_id r2) (decl_type (Sized (SReal AoS)))
           (initialize true)))
         (meta <opaque>))
        ((pattern
@@ -8543,22 +8546,22 @@
  (reverse_mode_log_prob ())
  (generate_quantities
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id p_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id p_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id p_upper) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id p_upper) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id p_lower) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id p_lower) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype DataOnly) (decl_id offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -8566,7 +8569,7 @@
      (Decl (decl_adtype DataOnly) (decl_id no_offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -8574,7 +8577,7 @@
      (Decl (decl_adtype DataOnly) (decl_id offset_no_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -8582,7 +8585,7 @@
      (Decl (decl_adtype DataOnly) (decl_id p_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -8590,9 +8593,9 @@
      (Decl (decl_adtype DataOnly) (decl_id p_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -8610,7 +8613,7 @@
      (Decl (decl_adtype DataOnly) (decl_id p_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -8620,9 +8623,9 @@
      (Decl (decl_adtype DataOnly) (decl_id p_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -8642,7 +8645,7 @@
      (Decl (decl_adtype DataOnly) (decl_id p_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -8652,9 +8655,9 @@
      (Decl (decl_adtype DataOnly) (decl_id p_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -8675,8 +8678,8 @@
      (Decl (decl_adtype DataOnly) (decl_id p_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -8698,7 +8701,7 @@
      (Decl (decl_adtype DataOnly) (decl_id p_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -8708,9 +8711,9 @@
      (Decl (decl_adtype DataOnly) (decl_id p_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -8740,7 +8743,7 @@
      (Decl (decl_adtype DataOnly) (decl_id p_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -8767,7 +8770,7 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -8775,9 +8778,9 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -8795,7 +8798,7 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -8805,9 +8808,9 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -8827,7 +8830,7 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -8837,9 +8840,9 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -8860,8 +8863,8 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -8883,7 +8886,7 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -8893,9 +8896,9 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -8925,7 +8928,7 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -8941,7 +8944,7 @@
       (initialize true)))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id tp_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id tp_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -9514,7 +9517,7 @@
       ((pattern (Return ())) (meta <opaque>)) ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id gq_r1) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id gq_r1) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -9526,7 +9529,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id gq_r2) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id gq_r2) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -9540,7 +9543,7 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -9548,9 +9551,9 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -9568,7 +9571,7 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -9578,9 +9581,9 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -9600,7 +9603,7 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -9610,9 +9613,9 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -9624,8 +9627,8 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -9647,7 +9650,7 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -9657,9 +9660,9 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -9689,7 +9692,7 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -9700,7 +9703,7 @@
      (Decl (decl_adtype DataOnly) (decl_id indices)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -9717,7 +9720,7 @@
      (Decl (decl_adtype DataOnly) (decl_id indexing_mat)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -9728,7 +9731,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res1)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -9739,7 +9742,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res2)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -9750,7 +9753,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res3)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -9761,7 +9764,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res11)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -9772,7 +9775,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res21)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -9783,7 +9786,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res31)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -9794,7 +9797,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res4)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -9804,7 +9807,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res5)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -10640,12 +10643,13 @@
   ((p_real
     ((begin_loc ((filename mother.stan) (line_num 599) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 599) (col_num 14) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
-     (out_trans Identity)))
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters) (out_trans Identity)))
    (p_upper
     ((begin_loc ((filename mother.stan) (line_num 600) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 600) (col_num 29) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters)
      (out_trans
       (Lower
        ((pattern (Var p_real))
@@ -10653,7 +10657,8 @@
    (p_lower
     ((begin_loc ((filename mother.stan) (line_num 601) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 601) (col_num 30) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters)
      (out_trans
       (Upper
        ((pattern (Var p_upper))
@@ -10662,10 +10667,10 @@
     ((begin_loc ((filename mother.stan) (line_num 602) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 602) (col_num 58) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block Parameters)
      (out_trans
@@ -10676,10 +10681,10 @@
     ((begin_loc ((filename mother.stan) (line_num 603) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 603) (col_num 51) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block Parameters)
      (out_trans
@@ -10689,10 +10694,10 @@
     ((begin_loc ((filename mother.stan) (line_num 604) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 604) (col_num 47) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block Parameters)
      (out_trans
@@ -10702,10 +10707,10 @@
     ((begin_loc ((filename mother.stan) (line_num 605) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 605) (col_num 38) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block Parameters)
      (out_trans
@@ -10715,16 +10720,16 @@
     ((begin_loc ((filename mother.stan) (line_num 606) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 606) (col_num 44) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray SReal
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS (SReal AoS)
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray SReal
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS (SReal AoS)
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -10749,12 +10754,12 @@
     ((begin_loc ((filename mother.stan) (line_num 608) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 608) (col_num 30) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -10763,18 +10768,18 @@
     ((begin_loc ((filename mother.stan) (line_num 609) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 609) (col_num 36) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -10795,12 +10800,12 @@
     ((begin_loc ((filename mother.stan) (line_num 611) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 611) (col_num 38) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -10809,18 +10814,18 @@
     ((begin_loc ((filename mother.stan) (line_num 612) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 612) (col_num 44) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -10843,16 +10848,16 @@
     ((begin_loc ((filename mother.stan) (line_num 614) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 614) (col_num 54) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (SMatrix AoS
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (SMatrix AoS
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -10882,7 +10887,7 @@
     ((begin_loc ((filename mother.stan) (line_num 616) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 616) (col_num 35) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern
           (FunApp (StanLib Minus__ FnPlain AoS)
@@ -10892,7 +10897,7 @@
          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -10901,9 +10906,9 @@
     ((begin_loc ((filename mother.stan) (line_num 617) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 617) (col_num 41) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern
             (FunApp (StanLib Minus__ FnPlain AoS)
@@ -10915,9 +10920,9 @@
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11022,7 +11027,7 @@
     ((begin_loc ((filename mother.stan) (line_num 620) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 620) (col_num 48) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern
           (FunApp (StanLib Plus__ FnPlain AoS)
@@ -11063,7 +11068,7 @@
          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11093,10 +11098,10 @@
     ((begin_loc ((filename mother.stan) (line_num 625) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 625) (col_num 39) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block TransformedParameters)
      (out_trans
@@ -11106,16 +11111,16 @@
     ((begin_loc ((filename mother.stan) (line_num 626) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 626) (col_num 45) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray SReal
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS (SReal AoS)
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray SReal
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS (SReal AoS)
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -11140,12 +11145,12 @@
     ((begin_loc ((filename mother.stan) (line_num 628) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 628) (col_num 31) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -11154,18 +11159,18 @@
     ((begin_loc ((filename mother.stan) (line_num 629) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 629) (col_num 37) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11186,12 +11191,12 @@
     ((begin_loc ((filename mother.stan) (line_num 631) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 631) (col_num 39) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -11200,18 +11205,18 @@
     ((begin_loc ((filename mother.stan) (line_num 632) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 632) (col_num 45) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11234,16 +11239,16 @@
     ((begin_loc ((filename mother.stan) (line_num 634) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 634) (col_num 55) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (SMatrix AoS
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (SMatrix AoS
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11273,7 +11278,7 @@
     ((begin_loc ((filename mother.stan) (line_num 636) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 636) (col_num 36) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern
           (FunApp (StanLib Minus__ FnPlain AoS)
@@ -11283,7 +11288,7 @@
          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -11292,9 +11297,9 @@
     ((begin_loc ((filename mother.stan) (line_num 637) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 637) (col_num 42) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern
             (FunApp (StanLib Minus__ FnPlain AoS)
@@ -11306,9 +11311,9 @@
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11413,7 +11418,7 @@
     ((begin_loc ((filename mother.stan) (line_num 640) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 640) (col_num 49) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern
           (FunApp (StanLib Plus__ FnPlain AoS)
@@ -11454,7 +11459,7 @@
          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11473,26 +11478,26 @@
    (tp_real
     ((begin_loc ((filename mother.stan) (line_num 642) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 642) (col_num 15) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
      (out_block TransformedParameters) (out_trans Identity)))
    (gq_r1
     ((begin_loc ((filename mother.stan) (line_num 733) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 733) (col_num 32) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
      (out_block GeneratedQuantities) (out_trans Identity)))
    (gq_r2
     ((begin_loc ((filename mother.stan) (line_num 734) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 734) (col_num 27) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
      (out_block GeneratedQuantities) (out_trans Identity)))
    (gq_real_1d_ar
     ((begin_loc ((filename mother.stan) (line_num 735) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 735) (col_num 39) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block GeneratedQuantities)
      (out_trans
@@ -11502,16 +11507,16 @@
     ((begin_loc ((filename mother.stan) (line_num 736) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 736) (col_num 45) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray SReal
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS (SReal AoS)
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray SReal
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS (SReal AoS)
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -11536,12 +11541,12 @@
     ((begin_loc ((filename mother.stan) (line_num 738) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 738) (col_num 31) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -11550,18 +11555,18 @@
     ((begin_loc ((filename mother.stan) (line_num 739) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 739) (col_num 37) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11582,12 +11587,12 @@
     ((begin_loc ((filename mother.stan) (line_num 741) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 741) (col_num 39) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -11596,18 +11601,18 @@
     ((begin_loc ((filename mother.stan) (line_num 742) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 742) (col_num 45) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11618,16 +11623,16 @@
     ((begin_loc ((filename mother.stan) (line_num 743) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 743) (col_num 55) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (SMatrix AoS
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (SMatrix AoS
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11657,7 +11662,7 @@
     ((begin_loc ((filename mother.stan) (line_num 745) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 745) (col_num 36) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern
           (FunApp (StanLib Minus__ FnPlain AoS)
@@ -11667,7 +11672,7 @@
          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -11676,9 +11681,9 @@
     ((begin_loc ((filename mother.stan) (line_num 746) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 746) (col_num 42) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern
             (FunApp (StanLib Minus__ FnPlain AoS)
@@ -11690,9 +11695,9 @@
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11797,7 +11802,7 @@
     ((begin_loc ((filename mother.stan) (line_num 749) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 749) (col_num 49) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern
           (FunApp (StanLib Plus__ FnPlain AoS)
@@ -11838,7 +11843,7 @@
          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11848,23 +11853,23 @@
     ((begin_loc ((filename mother.stan) (line_num 750) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 750) (col_num 35) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SInt
+      (SArray AoS (SInt AoS)
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SInt
+      (SArray AoS (SInt AoS)
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block GeneratedQuantities) (out_trans Identity)))
    (indexing_mat
     ((begin_loc ((filename mother.stan) (line_num 751) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 751) (col_num 37) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11874,13 +11879,13 @@
     ((begin_loc ((filename mother.stan) (line_num 752) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 752) (col_num 33) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11890,13 +11895,13 @@
     ((begin_loc ((filename mother.stan) (line_num 753) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 753) (col_num 33) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11906,13 +11911,13 @@
     ((begin_loc ((filename mother.stan) (line_num 754) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 754) (col_num 33) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11922,13 +11927,13 @@
     ((begin_loc ((filename mother.stan) (line_num 755) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 755) (col_num 34) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11938,13 +11943,13 @@
     ((begin_loc ((filename mother.stan) (line_num 756) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 756) (col_num 34) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11954,13 +11959,13 @@
     ((begin_loc ((filename mother.stan) (line_num 757) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 757) (col_num 34) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11970,12 +11975,12 @@
     ((begin_loc ((filename mother.stan) (line_num 758) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 758) (col_num 34) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -11984,12 +11989,12 @@
     ((begin_loc ((filename mother.stan) (line_num 759) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 759) (col_num 30) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
diff --git a/test/integration/good/code-gen/opencl/cpp.expected b/test/integration/good/code-gen/opencl/cpp.expected
index a81a4ca60..86bd943d0 100644
--- a/test/integration/good/code-gen/opencl/cpp.expected
+++ b/test/integration/good/code-gen/opencl/cpp.expected
@@ -785,10 +785,12 @@ class distributions_model final : public model_base_crtp<distributions_model> {
   std::vector<double> d_real_array;
   Eigen::Matrix<double,-1,1> d_vector_data__;
   Eigen::Matrix<double,1,-1> d_row_vector_data__;
-  matrix_cl<int> d_int_array_opencl__;
-  matrix_cl<double> d_real_array_opencl__;
-  matrix_cl<double> d_row_vector_opencl__;
-  matrix_cl<double> d_vector_opencl__;
+  stan::math::matrix_cl<int> d_int_opencl__;
+  stan::math::matrix_cl<int> d_int_array_opencl__;
+  stan::math::matrix_cl<double> d_real_opencl__;
+  stan::math::matrix_cl<stan::math::matrix_cl<double>> d_real_array_opencl__;
+  stan::math::matrix_cl<double> d_vector_opencl__;
+  stan::math::matrix_cl<double> d_row_vector_opencl__;
   Eigen::Map<Eigen::Matrix<double,-1,1>> d_vector{nullptr, 0};
   Eigen::Map<Eigen::Matrix<double,1,-1>> d_row_vector{nullptr, 0};
  public:
@@ -892,10 +894,32 @@ class distributions_model final : public model_base_crtp<distributions_model> {
       stan::math::validate_non_negative_index("p_vector", "d_int", d_int);
       current_statement__ = 770;
       stan::math::validate_non_negative_index("p_row_vector", "d_int", d_int);
+      current_statement__ = 756;
+      d_int_opencl__ = std::numeric_limits<int>::min();
+      current_statement__ = 756;
+      d_int_opencl__ = stan::math::to_matrix_cl(d_int);
+      current_statement__ = 758;
+      d_int_array_opencl__ = std::vector<int>(d_int,
+                               std::numeric_limits<int>::min());
+      current_statement__ = 758;
       d_int_array_opencl__ = stan::math::to_matrix_cl(d_int_array);
+      current_statement__ = 759;
+      d_real_opencl__ = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 759;
+      d_real_opencl__ = stan::math::to_matrix_cl(d_real);
+      current_statement__ = 761;
+      d_real_array_opencl__ = std::vector<double>(d_int,
+                                std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 761;
       d_real_array_opencl__ = stan::math::to_matrix_cl(d_real_array);
-      d_row_vector_opencl__ = stan::math::to_matrix_cl(d_row_vector);
+      current_statement__ = 763;
+      d_vector_opencl__ = stan::math::to_matrix_cl(d_vector);
+      current_statement__ = 763;
       d_vector_opencl__ = stan::math::to_matrix_cl(d_vector);
+      current_statement__ = 765;
+      d_row_vector_opencl__ = stan::math::to_matrix_cl(d_row_vector);
+      current_statement__ = 765;
+      d_row_vector_opencl__ = stan::math::to_matrix_cl(d_row_vector);
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
     }
@@ -968,52 +992,49 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  p_real);
       current_statement__ = 11;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 12;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 13;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 14;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 15;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 16;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 17;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, d_int);
+                                 d_int_array, d_int);
       current_statement__ = 18;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, d_real);
+                                 d_int_array, d_real);
       current_statement__ = 19;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, p_real);
+                                 d_int_array, p_real);
       current_statement__ = 20;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, d_vector_opencl__);
+                                 d_int_array, d_vector);
       current_statement__ = 21;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_int_array, p_vector);
       current_statement__ = 22;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, d_row_vector_opencl__);
+                                 d_int_array, d_row_vector);
       current_statement__ = 23;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_int_array, p_row_vector);
       current_statement__ = 24;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, d_real_array_opencl__);
+                                 d_int_array, d_real_array);
       current_statement__ = 25;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_int_array, p_real_array);
       current_statement__ = 26;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
                                  d_int);
@@ -1022,25 +1043,25 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 28;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 29;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 30;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 31;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
                                  p_real);
       current_statement__ = 32;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 33;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 34;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 35;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
                                  d_int);
@@ -1049,115 +1070,106 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 37;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 38;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 39;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 40;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
                                  p_real);
       current_statement__ = 41;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 42;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 43;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 44;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, d_int);
+                                 d_real_array, d_int);
       current_statement__ = 45;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, d_real);
+                                 d_real_array, d_real);
       current_statement__ = 46;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, d_real_array_opencl__);
+                                 d_real_array, d_real_array);
       current_statement__ = 47;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, d_vector_opencl__);
+                                 d_real_array, d_vector);
       current_statement__ = 48;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+                                 d_real_array, d_row_vector);
       current_statement__ = 49;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, p_real);
+                                 d_real_array, p_real);
       current_statement__ = 50;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array, p_real_array);
       current_statement__ = 51;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array, p_vector);
       current_statement__ = 52;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array, p_row_vector);
       current_statement__ = 53;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, d_int);
+                                 d_vector, d_int);
       current_statement__ = 54;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, d_real);
+                                 d_vector, d_real);
       current_statement__ = 55;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, d_real_array_opencl__);
+                                 d_vector, d_real_array);
       current_statement__ = 56;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, d_vector_opencl__);
+                                 d_vector, d_vector);
       current_statement__ = 57;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, d_row_vector_opencl__);
+                                 d_vector, d_row_vector);
       current_statement__ = 58;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, p_real);
+                                 d_vector, p_real);
       current_statement__ = 59;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_vector, p_real_array);
       current_statement__ = 60;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_vector, p_vector);
       current_statement__ = 61;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_vector, p_row_vector);
       current_statement__ = 62;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, d_int);
+                                 d_row_vector, d_int);
       current_statement__ = 63;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, d_real);
+                                 d_row_vector, d_real);
       current_statement__ = 64;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+                                 d_row_vector, d_real_array);
       current_statement__ = 65;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, d_vector_opencl__);
+                                 d_row_vector, d_vector);
       current_statement__ = 66;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+                                 d_row_vector, d_row_vector);
       current_statement__ = 67;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, p_real);
+                                 d_row_vector, p_real);
       current_statement__ = 68;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector, p_real_array);
       current_statement__ = 69;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector, p_vector);
       current_statement__ = 70;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector, p_row_vector);
       current_statement__ = 71;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
                                  d_int);
@@ -1166,130 +1178,106 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 73;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 74;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 75;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 76;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
                                  p_real);
       current_statement__ = 77;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 78;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 79;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 80;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+                                 p_real_array, d_int);
       current_statement__ = 81;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+                                 p_real_array, d_real);
       current_statement__ = 82;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+                                 p_real_array, d_real_array);
       current_statement__ = 83;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+                                 p_real_array, d_vector);
       current_statement__ = 84;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+                                 p_real_array, d_row_vector);
       current_statement__ = 85;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+                                 p_real_array, p_real);
       current_statement__ = 86;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array, p_real_array);
       current_statement__ = 87;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_real_array, p_vector);
       current_statement__ = 88;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_real_array, p_row_vector);
       current_statement__ = 89;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+                                 p_vector, d_int);
       current_statement__ = 90;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+                                 p_vector, d_real);
       current_statement__ = 91;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+                                 p_vector, d_real_array);
       current_statement__ = 92;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+                                 p_vector, d_vector);
       current_statement__ = 93;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+                                 p_vector, d_row_vector);
       current_statement__ = 94;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+                                 p_vector, p_real);
       current_statement__ = 95;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_vector, p_real_array);
       current_statement__ = 96;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector, p_vector);
       current_statement__ = 97;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_vector, p_row_vector);
       current_statement__ = 98;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+                                 p_row_vector, d_int);
       current_statement__ = 99;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+                                 p_row_vector, d_real);
       current_statement__ = 100;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+                                 p_row_vector, d_real_array);
       current_statement__ = 101;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+                                 p_row_vector, d_vector);
       current_statement__ = 102;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+                                 p_row_vector, d_row_vector);
       current_statement__ = 103;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+                                 p_row_vector, p_real);
       current_statement__ = 104;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_row_vector, p_real_array);
       current_statement__ = 105;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_row_vector, p_vector);
       current_statement__ = 106;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector, p_row_vector);
       current_statement__ = 107;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
                                  d_int);
@@ -1298,25 +1286,25 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 109;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 110;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 111;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 112;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
                                  p_real);
       current_statement__ = 113;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 114;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 115;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 116;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
                                  d_int);
@@ -1325,115 +1313,106 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 118;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 119;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 120;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 121;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
                                  p_real);
       current_statement__ = 122;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 123;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 124;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 125;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_int);
+                                 d_real_array, d_int);
       current_statement__ = 126;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_real);
+                                 d_real_array, d_real);
       current_statement__ = 127;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_real_array_opencl__);
+                                 d_real_array, d_real_array);
       current_statement__ = 128;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_vector_opencl__);
+                                 d_real_array, d_vector);
       current_statement__ = 129;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+                                 d_real_array, d_row_vector);
       current_statement__ = 130;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, p_real);
+                                 d_real_array, p_real);
       current_statement__ = 131;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array, p_real_array);
       current_statement__ = 132;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array, p_vector);
       current_statement__ = 133;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array, p_row_vector);
       current_statement__ = 134;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_int);
+                                 d_vector, d_int);
       current_statement__ = 135;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_real);
+                                 d_vector, d_real);
       current_statement__ = 136;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_real_array_opencl__);
+                                 d_vector, d_real_array);
       current_statement__ = 137;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_vector_opencl__);
+                                 d_vector, d_vector);
       current_statement__ = 138;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_row_vector_opencl__);
+                                 d_vector, d_row_vector);
       current_statement__ = 139;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, p_real);
+                                 d_vector, p_real);
       current_statement__ = 140;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_vector, p_real_array);
       current_statement__ = 141;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_vector, p_vector);
       current_statement__ = 142;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_vector, p_row_vector);
       current_statement__ = 143;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_int);
+                                 d_row_vector, d_int);
       current_statement__ = 144;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_real);
+                                 d_row_vector, d_real);
       current_statement__ = 145;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+                                 d_row_vector, d_real_array);
       current_statement__ = 146;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_vector_opencl__);
+                                 d_row_vector, d_vector);
       current_statement__ = 147;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+                                 d_row_vector, d_row_vector);
       current_statement__ = 148;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, p_real);
+                                 d_row_vector, p_real);
       current_statement__ = 149;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector, p_real_array);
       current_statement__ = 150;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector, p_vector);
       current_statement__ = 151;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector, p_row_vector);
       current_statement__ = 152;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
                                  d_int);
@@ -1442,1153 +1421,835 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 154;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 155;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 156;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 157;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
                                  p_real);
       current_statement__ = 158;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 159;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 160;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 161;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+                                 p_real_array, d_int);
       current_statement__ = 162;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+                                 p_real_array, d_real);
       current_statement__ = 163;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+                                 p_real_array, d_real_array);
       current_statement__ = 164;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+                                 p_real_array, d_vector);
       current_statement__ = 165;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+                                 p_real_array, d_row_vector);
       current_statement__ = 166;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+                                 p_real_array, p_real);
       current_statement__ = 167;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array, p_real_array);
       current_statement__ = 168;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_real_array, p_vector);
       current_statement__ = 169;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_real_array, p_row_vector);
       current_statement__ = 170;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+                                 p_vector, d_int);
       current_statement__ = 171;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+                                 p_vector, d_real);
       current_statement__ = 172;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+                                 p_vector, d_real_array);
       current_statement__ = 173;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+                                 p_vector, d_vector);
       current_statement__ = 174;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+                                 p_vector, d_row_vector);
       current_statement__ = 175;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+                                 p_vector, p_real);
       current_statement__ = 176;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_vector, p_real_array);
       current_statement__ = 177;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector, p_vector);
       current_statement__ = 178;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_vector, p_row_vector);
       current_statement__ = 179;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+                                 p_row_vector, d_int);
       current_statement__ = 180;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+                                 p_row_vector, d_real);
       current_statement__ = 181;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+                                 p_row_vector, d_real_array);
       current_statement__ = 182;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+                                 p_row_vector, d_vector);
       current_statement__ = 183;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+                                 p_row_vector, d_row_vector);
       current_statement__ = 184;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+                                 p_row_vector, p_real);
       current_statement__ = 185;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_row_vector, p_real_array);
       current_statement__ = 186;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_row_vector, p_vector);
       current_statement__ = 187;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector, p_row_vector);
       current_statement__ = 188;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, d_int);
       current_statement__ = 189;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, d_real);
       current_statement__ = 190;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, d_real_array);
       current_statement__ = 191;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, d_vector);
       current_statement__ = 192;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, d_row_vector);
       current_statement__ = 193;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, p_real);
       current_statement__ = 194;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, p_real_array);
       current_statement__ = 195;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, p_vector);
       current_statement__ = 196;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, p_row_vector);
       current_statement__ = 197;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, d_int);
       current_statement__ = 198;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, d_real);
       current_statement__ = 199;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, d_real_array);
       current_statement__ = 200;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, d_vector);
       current_statement__ = 201;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, d_row_vector);
       current_statement__ = 202;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, p_real);
       current_statement__ = 203;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, p_real_array);
       current_statement__ = 204;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, p_vector);
       current_statement__ = 205;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, p_row_vector);
       current_statement__ = 206;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, d_int);
       current_statement__ = 207;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, d_real);
       current_statement__ = 208;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, d_real_array);
       current_statement__ = 209;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, d_vector);
       current_statement__ = 210;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, d_row_vector);
       current_statement__ = 211;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, p_real);
       current_statement__ = 212;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, p_real_array);
       current_statement__ = 213;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, p_vector);
       current_statement__ = 214;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, p_row_vector);
       current_statement__ = 215;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, d_int);
       current_statement__ = 216;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, d_real);
       current_statement__ = 217;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, d_real_array);
       current_statement__ = 218;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, d_vector);
       current_statement__ = 219;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, d_row_vector);
       current_statement__ = 220;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, p_real);
       current_statement__ = 221;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, p_real_array);
       current_statement__ = 222;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, p_vector);
       current_statement__ = 223;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, p_row_vector);
       current_statement__ = 224;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, d_int);
       current_statement__ = 225;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, d_real);
       current_statement__ = 226;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, d_real_array);
       current_statement__ = 227;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, d_vector);
       current_statement__ = 228;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, d_row_vector);
       current_statement__ = 229;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, p_real);
       current_statement__ = 230;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, p_real_array);
       current_statement__ = 231;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, p_vector);
       current_statement__ = 232;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, p_row_vector);
       current_statement__ = 233;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, d_int);
       current_statement__ = 234;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, d_real);
       current_statement__ = 235;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, d_real_array);
       current_statement__ = 236;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, d_vector);
       current_statement__ = 237;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, d_row_vector);
       current_statement__ = 238;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, p_real);
       current_statement__ = 239;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, p_real_array);
       current_statement__ = 240;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, p_vector);
       current_statement__ = 241;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, p_row_vector);
       current_statement__ = 242;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, d_int);
       current_statement__ = 243;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, d_real);
       current_statement__ = 244;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, d_real_array);
       current_statement__ = 245;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, d_vector);
       current_statement__ = 246;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, d_row_vector);
       current_statement__ = 247;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, p_real);
       current_statement__ = 248;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, p_real_array);
       current_statement__ = 249;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, p_vector);
       current_statement__ = 250;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, p_row_vector);
       current_statement__ = 251;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, d_int);
       current_statement__ = 252;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, d_real);
       current_statement__ = 253;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, d_real_array);
       current_statement__ = 254;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, d_vector);
       current_statement__ = 255;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, d_row_vector);
       current_statement__ = 256;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, p_real);
       current_statement__ = 257;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, p_real_array);
       current_statement__ = 258;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, p_vector);
       current_statement__ = 259;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, p_row_vector);
       current_statement__ = 260;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, d_int);
       current_statement__ = 261;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, d_real);
       current_statement__ = 262;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, d_real_array);
       current_statement__ = 263;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, d_vector);
       current_statement__ = 264;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, d_row_vector);
       current_statement__ = 265;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, p_real);
       current_statement__ = 266;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, p_real_array);
       current_statement__ = 267;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, p_vector);
       current_statement__ = 268;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, p_row_vector);
       current_statement__ = 269;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, d_int);
       current_statement__ = 270;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, d_real);
       current_statement__ = 271;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, d_real_array);
       current_statement__ = 272;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, d_vector);
       current_statement__ = 273;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, d_row_vector);
       current_statement__ = 274;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, p_real);
       current_statement__ = 275;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, p_real_array);
       current_statement__ = 276;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, p_vector);
       current_statement__ = 277;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, p_row_vector);
       current_statement__ = 278;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, d_int);
       current_statement__ = 279;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, d_real);
       current_statement__ = 280;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, d_real_array);
       current_statement__ = 281;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, d_vector);
       current_statement__ = 282;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, d_row_vector);
       current_statement__ = 283;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, p_real);
       current_statement__ = 284;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, p_real_array);
       current_statement__ = 285;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, p_vector);
       current_statement__ = 286;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, p_row_vector);
       current_statement__ = 287;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, d_int);
       current_statement__ = 288;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, d_real);
       current_statement__ = 289;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, d_real_array);
       current_statement__ = 290;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, d_vector);
       current_statement__ = 291;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, d_row_vector);
       current_statement__ = 292;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, p_real);
       current_statement__ = 293;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, p_real_array);
       current_statement__ = 294;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, p_vector);
       current_statement__ = 295;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, p_row_vector);
       current_statement__ = 296;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, d_int);
       current_statement__ = 297;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, d_real);
       current_statement__ = 298;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, d_real_array);
       current_statement__ = 299;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, d_vector);
       current_statement__ = 300;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, d_row_vector);
       current_statement__ = 301;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, p_real);
       current_statement__ = 302;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, p_real_array);
       current_statement__ = 303;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, p_vector);
       current_statement__ = 304;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, p_row_vector);
       current_statement__ = 305;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, d_int);
       current_statement__ = 306;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, d_real);
       current_statement__ = 307;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, d_real_array);
       current_statement__ = 308;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, d_vector);
       current_statement__ = 309;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, d_row_vector);
       current_statement__ = 310;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, p_real);
       current_statement__ = 311;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, p_real_array);
       current_statement__ = 312;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, p_vector);
       current_statement__ = 313;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, p_row_vector);
       current_statement__ = 314;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, d_int);
       current_statement__ = 315;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, d_real);
       current_statement__ = 316;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, d_real_array);
       current_statement__ = 317;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, d_vector);
       current_statement__ = 318;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, d_row_vector);
       current_statement__ = 319;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, p_real);
       current_statement__ = 320;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, p_real_array);
       current_statement__ = 321;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, p_vector);
       current_statement__ = 322;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, p_row_vector);
       current_statement__ = 323;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, d_int);
       current_statement__ = 324;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, d_real);
       current_statement__ = 325;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, d_real_array);
       current_statement__ = 326;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, d_vector);
       current_statement__ = 327;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, d_row_vector);
       current_statement__ = 328;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, p_real);
       current_statement__ = 329;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, p_real_array);
       current_statement__ = 330;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, p_vector);
       current_statement__ = 331;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, p_row_vector);
       current_statement__ = 332;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, d_int);
       current_statement__ = 333;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, d_real);
       current_statement__ = 334;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, d_real_array);
       current_statement__ = 335;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, d_vector);
       current_statement__ = 336;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, d_row_vector);
       current_statement__ = 337;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, p_real);
       current_statement__ = 338;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, p_real_array);
       current_statement__ = 339;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, p_vector);
       current_statement__ = 340;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, p_row_vector);
       current_statement__ = 341;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, d_int);
       current_statement__ = 342;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, d_real);
       current_statement__ = 343;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, d_real_array);
       current_statement__ = 344;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, d_vector);
       current_statement__ = 345;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, d_row_vector);
       current_statement__ = 346;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, p_real);
       current_statement__ = 347;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, p_real_array);
       current_statement__ = 348;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, p_vector);
       current_statement__ = 349;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, p_row_vector);
       current_statement__ = 350;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, d_int);
       current_statement__ = 351;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, d_real);
       current_statement__ = 352;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, d_real_array);
       current_statement__ = 353;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, d_vector);
       current_statement__ = 354;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, d_row_vector);
       current_statement__ = 355;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, p_real);
       current_statement__ = 356;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, p_real_array);
       current_statement__ = 357;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, p_vector);
       current_statement__ = 358;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, p_row_vector);
       current_statement__ = 359;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, d_int);
       current_statement__ = 360;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, d_real);
       current_statement__ = 361;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, d_real_array);
       current_statement__ = 362;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, d_vector);
       current_statement__ = 363;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, d_row_vector);
       current_statement__ = 364;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, p_real);
       current_statement__ = 365;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, p_real_array);
       current_statement__ = 366;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, p_vector);
       current_statement__ = 367;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, p_row_vector);
       current_statement__ = 368;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, d_int);
       current_statement__ = 369;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, d_real);
       current_statement__ = 370;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, d_real_array);
       current_statement__ = 371;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, d_vector);
       current_statement__ = 372;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, d_row_vector);
       current_statement__ = 373;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, p_real);
       current_statement__ = 374;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, p_real_array);
       current_statement__ = 375;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, p_vector);
       current_statement__ = 376;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, p_row_vector);
       current_statement__ = 377;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, d_int);
       current_statement__ = 378;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, d_real);
       current_statement__ = 379;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, d_real_array);
       current_statement__ = 380;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, d_vector);
       current_statement__ = 381;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, d_row_vector);
       current_statement__ = 382;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, p_real);
       current_statement__ = 383;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, p_real_array);
       current_statement__ = 384;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, p_vector);
       current_statement__ = 385;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, p_row_vector);
       current_statement__ = 386;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, d_int);
       current_statement__ = 387;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, d_real);
       current_statement__ = 388;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, d_real_array);
       current_statement__ = 389;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, d_vector);
       current_statement__ = 390;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, d_row_vector);
       current_statement__ = 391;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, p_real);
       current_statement__ = 392;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, p_real_array);
       current_statement__ = 393;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, p_vector);
       current_statement__ = 394;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, p_row_vector);
       current_statement__ = 395;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, d_int);
       current_statement__ = 396;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, d_real);
       current_statement__ = 397;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, d_real_array);
       current_statement__ = 398;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, d_vector);
       current_statement__ = 399;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, d_row_vector);
       current_statement__ = 400;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, p_real);
       current_statement__ = 401;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, p_real_array);
       current_statement__ = 402;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, p_vector);
       current_statement__ = 403;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, p_row_vector);
       current_statement__ = 404;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, d_int);
       current_statement__ = 405;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, d_real);
       current_statement__ = 406;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, d_real_array);
       current_statement__ = 407;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, d_vector);
       current_statement__ = 408;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, d_row_vector);
       current_statement__ = 409;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, p_real);
       current_statement__ = 410;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, p_real_array);
       current_statement__ = 411;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, p_vector);
       current_statement__ = 412;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, p_row_vector);
       current_statement__ = 413;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, d_int);
       current_statement__ = 414;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, d_real);
       current_statement__ = 415;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, d_real_array);
       current_statement__ = 416;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, d_vector);
       current_statement__ = 417;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, d_row_vector);
       current_statement__ = 418;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, p_real);
       current_statement__ = 419;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, p_real_array);
       current_statement__ = 420;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, p_vector);
       current_statement__ = 421;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, p_row_vector);
       current_statement__ = 422;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, d_int);
       current_statement__ = 423;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, d_real);
       current_statement__ = 424;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, d_real_array);
       current_statement__ = 425;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, d_vector);
       current_statement__ = 426;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, d_row_vector);
       current_statement__ = 427;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, p_real);
       current_statement__ = 428;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, p_real_array);
       current_statement__ = 429;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, p_vector);
       current_statement__ = 430;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, p_row_vector);
       current_statement__ = 431;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
                                  d_int);
@@ -2597,25 +2258,25 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 433;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 434;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 435;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 436;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
                                  p_real);
       current_statement__ = 437;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 438;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 439;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 440;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
                                  d_int);
@@ -2624,115 +2285,106 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 442;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 443;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 444;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 445;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
                                  p_real);
       current_statement__ = 446;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 447;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 448;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 449;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, d_int);
+                                 d_real_array, d_int);
       current_statement__ = 450;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, d_real);
+                                 d_real_array, d_real);
       current_statement__ = 451;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, d_real_array_opencl__);
+                                 d_real_array, d_real_array);
       current_statement__ = 452;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, d_vector_opencl__);
+                                 d_real_array, d_vector);
       current_statement__ = 453;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+                                 d_real_array, d_row_vector);
       current_statement__ = 454;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, p_real);
+                                 d_real_array, p_real);
       current_statement__ = 455;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array, p_real_array);
       current_statement__ = 456;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array, p_vector);
       current_statement__ = 457;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array, p_row_vector);
       current_statement__ = 458;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, d_int);
+                                 d_vector, d_int);
       current_statement__ = 459;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, d_real);
+                                 d_vector, d_real);
       current_statement__ = 460;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, d_real_array_opencl__);
+                                 d_vector, d_real_array);
       current_statement__ = 461;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, d_vector_opencl__);
+                                 d_vector, d_vector);
       current_statement__ = 462;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, d_row_vector_opencl__);
+                                 d_vector, d_row_vector);
       current_statement__ = 463;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, p_real);
+                                 d_vector, p_real);
       current_statement__ = 464;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_vector, p_real_array);
       current_statement__ = 465;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_vector, p_vector);
       current_statement__ = 466;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_vector, p_row_vector);
       current_statement__ = 467;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, d_int);
+                                 d_row_vector, d_int);
       current_statement__ = 468;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, d_real);
+                                 d_row_vector, d_real);
       current_statement__ = 469;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+                                 d_row_vector, d_real_array);
       current_statement__ = 470;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, d_vector_opencl__);
+                                 d_row_vector, d_vector);
       current_statement__ = 471;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+                                 d_row_vector, d_row_vector);
       current_statement__ = 472;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, p_real);
+                                 d_row_vector, p_real);
       current_statement__ = 473;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector, p_real_array);
       current_statement__ = 474;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector, p_vector);
       current_statement__ = 475;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector, p_row_vector);
       current_statement__ = 476;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
                                  d_int);
@@ -2741,1221 +2393,839 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 478;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 479;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 480;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 481;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
                                  p_real);
       current_statement__ = 482;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 483;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 484;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 485;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+                                 p_real_array, d_int);
       current_statement__ = 486;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+                                 p_real_array, d_real);
       current_statement__ = 487;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+                                 p_real_array, d_real_array);
       current_statement__ = 488;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+                                 p_real_array, d_vector);
       current_statement__ = 489;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+                                 p_real_array, d_row_vector);
       current_statement__ = 490;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+                                 p_real_array, p_real);
       current_statement__ = 491;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array, p_real_array);
       current_statement__ = 492;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_real_array, p_vector);
       current_statement__ = 493;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_real_array, p_row_vector);
       current_statement__ = 494;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+                                 p_vector, d_int);
       current_statement__ = 495;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+                                 p_vector, d_real);
       current_statement__ = 496;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+                                 p_vector, d_real_array);
       current_statement__ = 497;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+                                 p_vector, d_vector);
       current_statement__ = 498;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+                                 p_vector, d_row_vector);
       current_statement__ = 499;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+                                 p_vector, p_real);
       current_statement__ = 500;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_vector, p_real_array);
       current_statement__ = 501;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector, p_vector);
       current_statement__ = 502;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_vector, p_row_vector);
       current_statement__ = 503;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+                                 p_row_vector, d_int);
       current_statement__ = 504;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+                                 p_row_vector, d_real);
       current_statement__ = 505;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+                                 p_row_vector, d_real_array);
       current_statement__ = 506;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+                                 p_row_vector, d_vector);
       current_statement__ = 507;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+                                 p_row_vector, d_row_vector);
       current_statement__ = 508;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+                                 p_row_vector, p_real);
       current_statement__ = 509;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_row_vector, p_real_array);
       current_statement__ = 510;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_row_vector, p_vector);
       current_statement__ = 511;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector, p_row_vector);
       current_statement__ = 512;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_int, d_int);
       current_statement__ = 513;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_int, d_real);
       current_statement__ = 514;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int, d_real_array);
       current_statement__ = 515;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int, d_vector);
       current_statement__ = 516;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int, d_row_vector);
       current_statement__ = 517;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_int, p_real);
       current_statement__ = 518;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int, p_real_array);
       current_statement__ = 519;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int, p_vector);
       current_statement__ = 520;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int, p_row_vector);
       current_statement__ = 521;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_real, d_int);
       current_statement__ = 522;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_real, d_real);
       current_statement__ = 523;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real, d_real_array);
       current_statement__ = 524;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real, d_vector);
       current_statement__ = 525;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real, d_row_vector);
       current_statement__ = 526;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_real, p_real);
       current_statement__ = 527;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real, p_real_array);
       current_statement__ = 528;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real, p_vector);
       current_statement__ = 529;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real, p_row_vector);
       current_statement__ = 530;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, d_int);
       current_statement__ = 531;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, d_real);
       current_statement__ = 532;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, d_real_array);
       current_statement__ = 533;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, d_vector);
       current_statement__ = 534;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, d_row_vector);
       current_statement__ = 535;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, p_real);
       current_statement__ = 536;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, p_real_array);
       current_statement__ = 537;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, p_vector);
       current_statement__ = 538;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, p_row_vector);
       current_statement__ = 539;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, d_int);
       current_statement__ = 540;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, d_real);
       current_statement__ = 541;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, d_real_array);
       current_statement__ = 542;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, d_vector);
       current_statement__ = 543;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, d_row_vector);
       current_statement__ = 544;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, p_real);
       current_statement__ = 545;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, p_real_array);
       current_statement__ = 546;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, p_vector);
       current_statement__ = 547;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, p_row_vector);
       current_statement__ = 548;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, d_int);
       current_statement__ = 549;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, d_real);
       current_statement__ = 550;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, d_real_array);
       current_statement__ = 551;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, d_vector);
       current_statement__ = 552;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, d_row_vector);
       current_statement__ = 553;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, p_real);
       current_statement__ = 554;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, p_real_array);
       current_statement__ = 555;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, p_vector);
       current_statement__ = 556;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, p_row_vector);
       current_statement__ = 557;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  p_real, d_int);
       current_statement__ = 558;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  p_real, d_real);
       current_statement__ = 559;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, d_real_array);
       current_statement__ = 560;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, d_vector);
       current_statement__ = 561;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, d_row_vector);
       current_statement__ = 562;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  p_real, p_real);
       current_statement__ = 563;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, p_real_array);
       current_statement__ = 564;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, p_vector);
       current_statement__ = 565;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, p_row_vector);
       current_statement__ = 566;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_int);
       current_statement__ = 567;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_real);
       current_statement__ = 568;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_real_array);
       current_statement__ = 569;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_vector);
       current_statement__ = 570;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_row_vector);
       current_statement__ = 571;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, p_real);
       current_statement__ = 572;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, p_real_array);
       current_statement__ = 573;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, p_vector);
       current_statement__ = 574;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, p_row_vector);
       current_statement__ = 575;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_int);
       current_statement__ = 576;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_real);
       current_statement__ = 577;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_real_array);
       current_statement__ = 578;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_vector);
       current_statement__ = 579;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_row_vector);
       current_statement__ = 580;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, p_real);
       current_statement__ = 581;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, p_real_array);
       current_statement__ = 582;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, p_vector);
       current_statement__ = 583;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, p_row_vector);
       current_statement__ = 584;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_int);
       current_statement__ = 585;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_real);
       current_statement__ = 586;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_real_array);
       current_statement__ = 587;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_vector);
       current_statement__ = 588;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_row_vector);
       current_statement__ = 589;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, p_real);
       current_statement__ = 590;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, p_real_array);
       current_statement__ = 591;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, p_vector);
       current_statement__ = 592;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, p_row_vector);
       current_statement__ = 593;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, d_int);
       current_statement__ = 594;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, d_real);
       current_statement__ = 595;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, d_real_array);
       current_statement__ = 596;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, d_vector);
       current_statement__ = 597;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, d_row_vector);
       current_statement__ = 598;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, p_real);
       current_statement__ = 599;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, p_real_array);
       current_statement__ = 600;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, p_vector);
       current_statement__ = 601;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, p_row_vector);
       current_statement__ = 602;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, d_int);
       current_statement__ = 603;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, d_real);
       current_statement__ = 604;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, d_real_array);
       current_statement__ = 605;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, d_vector);
       current_statement__ = 606;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, d_row_vector);
       current_statement__ = 607;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, p_real);
       current_statement__ = 608;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, p_real_array);
       current_statement__ = 609;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, p_vector);
       current_statement__ = 610;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, p_row_vector);
       current_statement__ = 611;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, d_int);
       current_statement__ = 612;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, d_real);
       current_statement__ = 613;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, d_real_array);
       current_statement__ = 614;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, d_vector);
       current_statement__ = 615;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, d_row_vector);
       current_statement__ = 616;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, p_real);
       current_statement__ = 617;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, p_real_array);
       current_statement__ = 618;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, p_vector);
       current_statement__ = 619;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, p_row_vector);
       current_statement__ = 620;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, d_int);
       current_statement__ = 621;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, d_real);
       current_statement__ = 622;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, d_real_array);
       current_statement__ = 623;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, d_vector);
       current_statement__ = 624;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, d_row_vector);
       current_statement__ = 625;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, p_real);
       current_statement__ = 626;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, p_real_array);
       current_statement__ = 627;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, p_vector);
       current_statement__ = 628;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, p_row_vector);
       current_statement__ = 629;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, d_int);
       current_statement__ = 630;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, d_real);
       current_statement__ = 631;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, d_real_array);
       current_statement__ = 632;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, d_vector);
       current_statement__ = 633;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, d_row_vector);
       current_statement__ = 634;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, p_real);
       current_statement__ = 635;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, p_real_array);
       current_statement__ = 636;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, p_vector);
       current_statement__ = 637;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, p_row_vector);
       current_statement__ = 638;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_int);
       current_statement__ = 639;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_real);
       current_statement__ = 640;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_real_array);
       current_statement__ = 641;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_vector);
       current_statement__ = 642;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_row_vector);
       current_statement__ = 643;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, p_real);
       current_statement__ = 644;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, p_real_array);
       current_statement__ = 645;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, p_vector);
       current_statement__ = 646;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, p_row_vector);
       current_statement__ = 647;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_int);
       current_statement__ = 648;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_real);
       current_statement__ = 649;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_real_array);
       current_statement__ = 650;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_vector);
       current_statement__ = 651;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_row_vector);
       current_statement__ = 652;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, p_real);
       current_statement__ = 653;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, p_real_array);
       current_statement__ = 654;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, p_vector);
       current_statement__ = 655;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, p_row_vector);
       current_statement__ = 656;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_int);
       current_statement__ = 657;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_real);
       current_statement__ = 658;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_real_array);
       current_statement__ = 659;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_vector);
       current_statement__ = 660;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_row_vector);
       current_statement__ = 661;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, p_real);
       current_statement__ = 662;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, p_real_array);
       current_statement__ = 663;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, p_vector);
       current_statement__ = 664;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, p_row_vector);
       current_statement__ = 665;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_int);
       current_statement__ = 666;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_real);
       current_statement__ = 667;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_real_array);
       current_statement__ = 668;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_vector);
       current_statement__ = 669;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_row_vector);
       current_statement__ = 670;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, p_real);
       current_statement__ = 671;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, p_real_array);
       current_statement__ = 672;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, p_vector);
       current_statement__ = 673;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, p_row_vector);
       current_statement__ = 674;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_int, d_int);
       current_statement__ = 675;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_int, d_real);
       current_statement__ = 676;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int, d_real_array);
       current_statement__ = 677;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int, d_vector);
       current_statement__ = 678;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int, d_row_vector);
       current_statement__ = 679;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_int, p_real);
       current_statement__ = 680;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int, p_real_array);
       current_statement__ = 681;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int, p_vector);
       current_statement__ = 682;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int, p_row_vector);
       current_statement__ = 683;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_real, d_int);
       current_statement__ = 684;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_real, d_real);
       current_statement__ = 685;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real, d_real_array);
       current_statement__ = 686;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real, d_vector);
       current_statement__ = 687;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real, d_row_vector);
       current_statement__ = 688;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_real, p_real);
       current_statement__ = 689;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real, p_real_array);
       current_statement__ = 690;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real, p_vector);
       current_statement__ = 691;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real, p_row_vector);
       current_statement__ = 692;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, d_int);
       current_statement__ = 693;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, d_real);
       current_statement__ = 694;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, d_real_array);
       current_statement__ = 695;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, d_vector);
       current_statement__ = 696;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, d_row_vector);
       current_statement__ = 697;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, p_real);
       current_statement__ = 698;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, p_real_array);
       current_statement__ = 699;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, p_vector);
       current_statement__ = 700;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, p_row_vector);
       current_statement__ = 701;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, d_int);
       current_statement__ = 702;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, d_real);
       current_statement__ = 703;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, d_real_array);
       current_statement__ = 704;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, d_vector);
       current_statement__ = 705;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, d_row_vector);
       current_statement__ = 706;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, p_real);
       current_statement__ = 707;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, p_real_array);
       current_statement__ = 708;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, p_vector);
       current_statement__ = 709;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, p_row_vector);
       current_statement__ = 710;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, d_int);
       current_statement__ = 711;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, d_real);
       current_statement__ = 712;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, d_real_array);
       current_statement__ = 713;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, d_vector);
       current_statement__ = 714;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, d_row_vector);
       current_statement__ = 715;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, p_real);
       current_statement__ = 716;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, p_real_array);
       current_statement__ = 717;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, p_vector);
       current_statement__ = 718;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, p_row_vector);
       current_statement__ = 719;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  p_real, d_int);
       current_statement__ = 720;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  p_real, d_real);
       current_statement__ = 721;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, d_real_array);
       current_statement__ = 722;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, d_vector);
       current_statement__ = 723;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, d_row_vector);
       current_statement__ = 724;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  p_real, p_real);
       current_statement__ = 725;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, p_real_array);
       current_statement__ = 726;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, p_vector);
       current_statement__ = 727;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, p_row_vector);
       current_statement__ = 728;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_int);
       current_statement__ = 729;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_real);
       current_statement__ = 730;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_real_array);
       current_statement__ = 731;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_vector);
       current_statement__ = 732;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_row_vector);
       current_statement__ = 733;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, p_real);
       current_statement__ = 734;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, p_real_array);
       current_statement__ = 735;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, p_vector);
       current_statement__ = 736;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, p_row_vector);
       current_statement__ = 737;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_int);
       current_statement__ = 738;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_real);
       current_statement__ = 739;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_real_array);
       current_statement__ = 740;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_vector);
       current_statement__ = 741;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_row_vector);
       current_statement__ = 742;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, p_real);
       current_statement__ = 743;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, p_real_array);
       current_statement__ = 744;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, p_vector);
       current_statement__ = 745;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, p_row_vector);
       current_statement__ = 746;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_int);
       current_statement__ = 747;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_real);
       current_statement__ = 748;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_real_array);
       current_statement__ = 749;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_vector);
       current_statement__ = 750;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_row_vector);
       current_statement__ = 751;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, p_real);
       current_statement__ = 752;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, p_real_array);
       current_statement__ = 753;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, p_vector);
       current_statement__ = 754;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, p_row_vector);
       {
         current_statement__ = 755;
         lp_accum__.add(stan::math::normal_lpdf<propto__>(y_p, 0, 1));
       }
-      d_int_array_opencl__.wait_for_read_write_events();
-      d_real_array_opencl__.wait_for_read_write_events();
-      d_row_vector_opencl__.wait_for_read_write_events();
-      d_vector_opencl__.wait_for_read_write_events();
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
     }
@@ -3984,66 +3254,76 @@ class distributions_model final : public model_base_crtp<distributions_model> {
     // suppress unused var warning
     (void) function__;
     try {
-      local_scalar_t__ p_real = DUMMY_VAR__;
+      stan::math::matrix_cl<local_scalar_t__> p_real = DUMMY_VAR__;
       current_statement__ = 1;
-      p_real = in__.template read<local_scalar_t__>();
-      std::vector<local_scalar_t__> p_real_array =
-        std::vector<local_scalar_t__>(d_int, DUMMY_VAR__);
-      current_statement__ = 2;
-      p_real_array = in__.template read<std::vector<local_scalar_t__>>(d_int);
-      Eigen::Matrix<local_scalar_t__,-1,-1> p_matrix =
-        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(d_int, d_int,
+      p_real = in__.template read<stan::math::matrix_cl<local_scalar_t__>>();
+      std::vector<stan::math::matrix_cl<local_scalar_t__>> p_real_array =
+        std::vector<stan::math::matrix_cl<local_scalar_t__>>(d_int,
           DUMMY_VAR__);
+      current_statement__ = 2;
+      p_real_array = in__.template read<
+                       std::vector<stan::math::matrix_cl<local_scalar_t__>>>(d_int);
+      stan::math::var_value<stan::math::matrix_cl<double>> p_matrix =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,-1>::Constant(d_int,
+                                                               d_int,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
       current_statement__ = 3;
       p_matrix = in__.template read<
-                   Eigen::Matrix<local_scalar_t__,-1,-1>>(d_int, d_int);
-      Eigen::Matrix<local_scalar_t__,-1,1> p_vector =
-        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(d_int, DUMMY_VAR__);
+                   stan::math::var_value<stan::math::matrix_cl<double>>>(d_int,
+                   d_int);
+      stan::math::var_value<stan::math::matrix_cl<double>> p_vector =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,1>::Constant(d_int,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
       current_statement__ = 4;
       p_vector = in__.template read<
-                   Eigen::Matrix<local_scalar_t__,-1,1>>(d_int);
-      Eigen::Matrix<local_scalar_t__,1,-1> p_row_vector =
-        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(d_int, DUMMY_VAR__);
+                   stan::math::var_value<stan::math::matrix_cl<double>>>(d_int);
+      stan::math::var_value<stan::math::matrix_cl<double>> p_row_vector =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,1,-1>::Constant(d_int,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
       current_statement__ = 5;
       p_row_vector = in__.template read<
-                       Eigen::Matrix<local_scalar_t__,1,-1>>(d_int);
-      local_scalar_t__ y_p = DUMMY_VAR__;
+                       stan::math::var_value<stan::math::matrix_cl<double>>>(d_int);
+      stan::math::matrix_cl<local_scalar_t__> y_p = DUMMY_VAR__;
       current_statement__ = 6;
-      y_p = in__.template read<local_scalar_t__>();
-      local_scalar_t__ transformed_param_real = DUMMY_VAR__;
+      y_p = in__.template read<stan::math::matrix_cl<local_scalar_t__>>();
+      stan::math::matrix_cl<local_scalar_t__> transformed_param_real =
+        DUMMY_VAR__;
       current_statement__ = 8;
-      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 d_int);
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
+                                 d_int_opencl__, d_int_opencl__);
       current_statement__ = 9;
-      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 d_real);
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
+                                 d_int_opencl__, d_real_opencl__);
       current_statement__ = 10;
-      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 p_real);
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
+                                 d_int_opencl__, p_real);
       current_statement__ = 11;
-      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
+                                 d_int_opencl__, d_vector_opencl__);
       current_statement__ = 12;
-      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
+                                 d_int_opencl__, p_vector);
       current_statement__ = 13;
-      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
+                                 d_int_opencl__, d_row_vector_opencl__);
       current_statement__ = 14;
-      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
+                                 d_int_opencl__, p_row_vector);
       current_statement__ = 15;
-      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
+                                 d_int_opencl__, d_real_array_opencl__);
       current_statement__ = 16;
-      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
+                                 d_int_opencl__, p_real_array);
       current_statement__ = 17;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, d_int);
+                                 d_int_array_opencl__, d_int_opencl__);
       current_statement__ = 18;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, d_real);
+                                 d_int_array_opencl__, d_real_opencl__);
       current_statement__ = 19;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
                                  d_int_array_opencl__, p_real);
@@ -4052,648 +3332,638 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_int_array_opencl__, d_vector_opencl__);
       current_statement__ = 21;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_int_array_opencl__, p_vector);
       current_statement__ = 22;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
                                  d_int_array_opencl__, d_row_vector_opencl__);
       current_statement__ = 23;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_int_array_opencl__, p_row_vector);
       current_statement__ = 24;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
                                  d_int_array_opencl__, d_real_array_opencl__);
       current_statement__ = 25;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_int_array_opencl__, p_real_array);
       current_statement__ = 26;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_int_opencl__, d_int_opencl__);
       current_statement__ = 27;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_int_opencl__, d_real_opencl__);
       current_statement__ = 28;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_int_opencl__, d_real_array_opencl__);
       current_statement__ = 29;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_int_opencl__, d_vector_opencl__);
       current_statement__ = 30;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_int_opencl__, d_row_vector_opencl__);
       current_statement__ = 31;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_int_opencl__, p_real);
       current_statement__ = 32;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_int_opencl__, p_real_array);
       current_statement__ = 33;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_int_opencl__, p_vector);
       current_statement__ = 34;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_int_opencl__, p_row_vector);
       current_statement__ = 35;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_opencl__, d_int_opencl__);
       current_statement__ = 36;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_opencl__, d_real_opencl__);
       current_statement__ = 37;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_opencl__, d_real_array_opencl__);
       current_statement__ = 38;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_opencl__, d_vector_opencl__);
       current_statement__ = 39;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_opencl__, d_row_vector_opencl__);
       current_statement__ = 40;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_opencl__, p_real);
       current_statement__ = 41;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_opencl__, p_real_array);
       current_statement__ = 42;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_opencl__, p_vector);
       current_statement__ = 43;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_opencl__, p_row_vector);
       current_statement__ = 44;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_array_opencl__, d_int_opencl__);
       current_statement__ = 45;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_array_opencl__, d_real_opencl__);
       current_statement__ = 46;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
                                  d_real_array_opencl__, d_real_array_opencl__);
       current_statement__ = 47;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
                                  d_real_array_opencl__, d_vector_opencl__);
       current_statement__ = 48;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
                                  d_real_array_opencl__, d_row_vector_opencl__);
       current_statement__ = 49;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
                                  d_real_array_opencl__, p_real);
       current_statement__ = 50;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_array_opencl__, p_real_array);
       current_statement__ = 51;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_array_opencl__, p_vector);
       current_statement__ = 52;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_real_array_opencl__, p_row_vector);
       current_statement__ = 53;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_vector_opencl__, d_int_opencl__);
       current_statement__ = 54;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_vector_opencl__, d_real_opencl__);
       current_statement__ = 55;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
                                  d_vector_opencl__, d_real_array_opencl__);
       current_statement__ = 56;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
                                  d_vector_opencl__, d_vector_opencl__);
       current_statement__ = 57;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
                                  d_vector_opencl__, d_row_vector_opencl__);
       current_statement__ = 58;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
                                  d_vector_opencl__, p_real);
       current_statement__ = 59;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_vector_opencl__, p_real_array);
       current_statement__ = 60;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_vector_opencl__, p_vector);
       current_statement__ = 61;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_vector_opencl__, p_row_vector);
       current_statement__ = 62;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_row_vector_opencl__, d_int_opencl__);
       current_statement__ = 63;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_row_vector_opencl__, d_real_opencl__);
       current_statement__ = 64;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
                                  d_row_vector_opencl__, d_real_array_opencl__);
       current_statement__ = 65;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
                                  d_row_vector_opencl__, d_vector_opencl__);
       current_statement__ = 66;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
                                  d_row_vector_opencl__, d_row_vector_opencl__);
       current_statement__ = 67;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
                                  d_row_vector_opencl__, p_real);
       current_statement__ = 68;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_row_vector_opencl__, p_real_array);
       current_statement__ = 69;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_row_vector_opencl__, p_vector);
       current_statement__ = 70;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 d_row_vector_opencl__, p_row_vector);
       current_statement__ = 71;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real, d_int_opencl__);
       current_statement__ = 72;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real, d_real_opencl__);
       current_statement__ = 73;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real, d_real_array_opencl__);
       current_statement__ = 74;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real, d_vector_opencl__);
       current_statement__ = 75;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real, d_row_vector_opencl__);
       current_statement__ = 76;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real, p_real);
       current_statement__ = 77;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real, p_real_array);
       current_statement__ = 78;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real, p_vector);
       current_statement__ = 79;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real, p_row_vector);
       current_statement__ = 80;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real_array, d_int_opencl__);
       current_statement__ = 81;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real_array, d_real_opencl__);
       current_statement__ = 82;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real_array, d_real_array_opencl__);
       current_statement__ = 83;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real_array, d_vector_opencl__);
       current_statement__ = 84;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real_array, d_row_vector_opencl__);
       current_statement__ = 85;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real_array, p_real);
       current_statement__ = 86;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real_array, p_real_array);
       current_statement__ = 87;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real_array, p_vector);
       current_statement__ = 88;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_real_array, p_row_vector);
       current_statement__ = 89;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_vector, d_int_opencl__);
       current_statement__ = 90;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_vector, d_real_opencl__);
       current_statement__ = 91;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_vector, d_real_array_opencl__);
       current_statement__ = 92;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_vector, d_vector_opencl__);
       current_statement__ = 93;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_vector, d_row_vector_opencl__);
       current_statement__ = 94;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_vector, p_real);
       current_statement__ = 95;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_vector, p_real_array);
       current_statement__ = 96;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_vector, p_vector);
       current_statement__ = 97;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_vector, p_row_vector);
       current_statement__ = 98;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_row_vector, d_int_opencl__);
       current_statement__ = 99;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_row_vector, d_real_opencl__);
       current_statement__ = 100;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_row_vector, d_real_array_opencl__);
       current_statement__ = 101;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_row_vector, d_vector_opencl__);
       current_statement__ = 102;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_row_vector, d_row_vector_opencl__);
       current_statement__ = 103;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_row_vector, p_real);
       current_statement__ = 104;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_row_vector, p_real_array);
       current_statement__ = 105;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_row_vector, p_vector);
       current_statement__ = 106;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_int_opencl__,
+                                 p_row_vector, p_row_vector);
       current_statement__ = 107;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_int_opencl__,
+                                 d_int_opencl__);
       current_statement__ = 108;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_int_opencl__,
+                                 d_real_opencl__);
       current_statement__ = 109;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_int_opencl__,
                                  d_real_array_opencl__);
       current_statement__ = 110;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_int_opencl__,
                                  d_vector_opencl__);
       current_statement__ = 111;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_int_opencl__,
                                  d_row_vector_opencl__);
       current_statement__ = 112;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_int_opencl__, p_real);
       current_statement__ = 113;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_int_opencl__,
+                                 p_real_array);
       current_statement__ = 114;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_int_opencl__, p_vector);
       current_statement__ = 115;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_int_opencl__,
+                                 p_row_vector);
       current_statement__ = 116;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_opencl__,
+                                 d_int_opencl__);
       current_statement__ = 117;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_opencl__,
+                                 d_real_opencl__);
       current_statement__ = 118;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_opencl__,
                                  d_real_array_opencl__);
       current_statement__ = 119;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_opencl__,
                                  d_vector_opencl__);
       current_statement__ = 120;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_opencl__,
                                  d_row_vector_opencl__);
       current_statement__ = 121;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_opencl__, p_real);
       current_statement__ = 122;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_opencl__,
+                                 p_real_array);
       current_statement__ = 123;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_opencl__, p_vector);
       current_statement__ = 124;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_opencl__,
+                                 p_row_vector);
       current_statement__ = 125;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_array_opencl__,
+                                 d_int_opencl__);
       current_statement__ = 126;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_array_opencl__,
+                                 d_real_opencl__);
       current_statement__ = 127;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_array_opencl__,
+                                 d_real_array_opencl__);
       current_statement__ = 128;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_array_opencl__,
+                                 d_vector_opencl__);
       current_statement__ = 129;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_array_opencl__,
+                                 d_row_vector_opencl__);
       current_statement__ = 130;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_array_opencl__,
+                                 p_real);
       current_statement__ = 131;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_array_opencl__,
+                                 p_real_array);
       current_statement__ = 132;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_array_opencl__,
+                                 p_vector);
       current_statement__ = 133;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_real_array_opencl__,
+                                 p_row_vector);
       current_statement__ = 134;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_vector_opencl__,
+                                 d_int_opencl__);
       current_statement__ = 135;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_vector_opencl__,
+                                 d_real_opencl__);
       current_statement__ = 136;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_vector_opencl__,
+                                 d_real_array_opencl__);
       current_statement__ = 137;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_vector_opencl__,
+                                 d_vector_opencl__);
       current_statement__ = 138;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_vector_opencl__,
+                                 d_row_vector_opencl__);
       current_statement__ = 139;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_vector_opencl__, p_real);
       current_statement__ = 140;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_vector_opencl__,
+                                 p_real_array);
       current_statement__ = 141;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_vector_opencl__, p_vector);
       current_statement__ = 142;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_vector_opencl__,
+                                 p_row_vector);
       current_statement__ = 143;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_row_vector_opencl__,
+                                 d_int_opencl__);
       current_statement__ = 144;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_row_vector_opencl__,
+                                 d_real_opencl__);
       current_statement__ = 145;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_row_vector_opencl__,
+                                 d_real_array_opencl__);
       current_statement__ = 146;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_row_vector_opencl__,
+                                 d_vector_opencl__);
       current_statement__ = 147;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_row_vector_opencl__,
+                                 d_row_vector_opencl__);
       current_statement__ = 148;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_row_vector_opencl__,
+                                 p_real);
       current_statement__ = 149;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_row_vector_opencl__,
+                                 p_real_array);
       current_statement__ = 150;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_row_vector_opencl__,
+                                 p_vector);
       current_statement__ = 151;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, d_row_vector_opencl__,
+                                 p_row_vector);
       current_statement__ = 152;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real, d_int_opencl__);
       current_statement__ = 153;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real, d_real_opencl__);
       current_statement__ = 154;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real,
                                  d_real_array_opencl__);
       current_statement__ = 155;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real, d_vector_opencl__);
       current_statement__ = 156;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real,
                                  d_row_vector_opencl__);
       current_statement__ = 157;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real, p_real);
       current_statement__ = 158;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real, p_real_array);
       current_statement__ = 159;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real, p_vector);
       current_statement__ = 160;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real, p_row_vector);
       current_statement__ = 161;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real_array,
+                                 d_int_opencl__);
       current_statement__ = 162;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real_array,
+                                 d_real_opencl__);
       current_statement__ = 163;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real_array,
                                  d_real_array_opencl__);
       current_statement__ = 164;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real_array,
                                  d_vector_opencl__);
       current_statement__ = 165;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real_array,
                                  d_row_vector_opencl__);
       current_statement__ = 166;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real_array, p_real);
       current_statement__ = 167;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real_array, p_real_array);
       current_statement__ = 168;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real_array, p_vector);
       current_statement__ = 169;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_real_array, p_row_vector);
       current_statement__ = 170;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_vector, d_int_opencl__);
       current_statement__ = 171;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_vector, d_real_opencl__);
       current_statement__ = 172;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_vector,
                                  d_real_array_opencl__);
       current_statement__ = 173;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_vector, d_vector_opencl__);
       current_statement__ = 174;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_vector,
                                  d_row_vector_opencl__);
       current_statement__ = 175;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_vector, p_real);
       current_statement__ = 176;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_vector, p_real_array);
       current_statement__ = 177;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_vector, p_vector);
       current_statement__ = 178;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_vector, p_row_vector);
       current_statement__ = 179;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_row_vector,
+                                 d_int_opencl__);
       current_statement__ = 180;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_row_vector,
+                                 d_real_opencl__);
       current_statement__ = 181;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_row_vector,
                                  d_real_array_opencl__);
       current_statement__ = 182;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_row_vector,
                                  d_vector_opencl__);
       current_statement__ = 183;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_row_vector,
                                  d_row_vector_opencl__);
       current_statement__ = 184;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_row_vector, p_real);
       current_statement__ = 185;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_row_vector, p_real_array);
       current_statement__ = 186;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_row_vector, p_vector);
       current_statement__ = 187;
-      transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(
+                                 d_real_opencl__, p_row_vector, p_row_vector);
       current_statement__ = 188;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int, d_int);
+                                 d_real_array_opencl__, d_int_opencl__,
+                                 d_int_opencl__);
       current_statement__ = 189;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int, d_real);
+                                 d_real_array_opencl__, d_int_opencl__,
+                                 d_real_opencl__);
       current_statement__ = 190;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
+                                 d_real_array_opencl__, d_int_opencl__,
                                  d_real_array_opencl__);
       current_statement__ = 191;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
+                                 d_real_array_opencl__, d_int_opencl__,
                                  d_vector_opencl__);
       current_statement__ = 192;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
+                                 d_real_array_opencl__, d_int_opencl__,
                                  d_row_vector_opencl__);
       current_statement__ = 193;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int, p_real);
+                                 d_real_array_opencl__, d_int_opencl__,
+                                 p_real);
       current_statement__ = 194;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array_opencl__, d_int_opencl__,
+                                 p_real_array);
       current_statement__ = 195;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array_opencl__, d_int_opencl__,
+                                 p_vector);
       current_statement__ = 196;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array_opencl__, d_int_opencl__,
+                                 p_row_vector);
       current_statement__ = 197;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real, d_int);
+                                 d_real_array_opencl__, d_real_opencl__,
+                                 d_int_opencl__);
       current_statement__ = 198;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real, d_real);
+                                 d_real_array_opencl__, d_real_opencl__,
+                                 d_real_opencl__);
       current_statement__ = 199;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
+                                 d_real_array_opencl__, d_real_opencl__,
                                  d_real_array_opencl__);
       current_statement__ = 200;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
+                                 d_real_array_opencl__, d_real_opencl__,
                                  d_vector_opencl__);
       current_statement__ = 201;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
+                                 d_real_array_opencl__, d_real_opencl__,
                                  d_row_vector_opencl__);
       current_statement__ = 202;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real, p_real);
+                                 d_real_array_opencl__, d_real_opencl__,
+                                 p_real);
       current_statement__ = 203;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array_opencl__, d_real_opencl__,
+                                 p_real_array);
       current_statement__ = 204;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array_opencl__, d_real_opencl__,
+                                 p_vector);
       current_statement__ = 205;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array_opencl__, d_real_opencl__,
+                                 p_row_vector);
       current_statement__ = 206;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__,
-                                 d_real_array_opencl__, d_int);
+                                 d_real_array_opencl__, d_int_opencl__);
       current_statement__ = 207;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__,
-                                 d_real_array_opencl__, d_real);
+                                 d_real_array_opencl__, d_real_opencl__);
       current_statement__ = 208;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__,
@@ -4713,26 +3983,23 @@ class distributions_model final : public model_base_crtp<distributions_model> {
       current_statement__ = 212;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array_opencl__, p_real_array);
       current_statement__ = 213;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array_opencl__, p_vector);
       current_statement__ = 214;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array_opencl__, p_row_vector);
       current_statement__ = 215;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__, d_vector_opencl__,
-                                 d_int);
+                                 d_int_opencl__);
       current_statement__ = 216;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__, d_vector_opencl__,
-                                 d_real);
+                                 d_real_opencl__);
       current_statement__ = 217;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__, d_vector_opencl__,
@@ -4752,23 +4019,23 @@ class distributions_model final : public model_base_crtp<distributions_model> {
       current_statement__ = 221;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 222;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 223;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 224;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__,
-                                 d_row_vector_opencl__, d_int);
+                                 d_row_vector_opencl__, d_int_opencl__);
       current_statement__ = 225;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__,
-                                 d_row_vector_opencl__, d_real);
+                                 d_row_vector_opencl__, d_real_opencl__);
       current_statement__ = 226;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__,
@@ -4788,24 +4055,23 @@ class distributions_model final : public model_base_crtp<distributions_model> {
       current_statement__ = 230;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector_opencl__, p_real_array);
       current_statement__ = 231;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector_opencl__, p_vector);
       current_statement__ = 232;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector_opencl__, p_row_vector);
       current_statement__ = 233;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real, d_int);
+                                 d_real_array_opencl__, p_real,
+                                 d_int_opencl__);
       current_statement__ = 234;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real, d_real);
+                                 d_real_array_opencl__, p_real,
+                                 d_real_opencl__);
       current_statement__ = 235;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_real_array_opencl__, p_real,
@@ -4823,220 +4089,193 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real_array_opencl__, p_real, p_real);
       current_statement__ = 239;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array_opencl__, p_real, p_real_array);
       current_statement__ = 240;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array_opencl__, p_real, p_vector);
       current_statement__ = 241;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array_opencl__, p_real, p_row_vector);
       current_statement__ = 242;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+                                 d_real_array_opencl__, p_real_array,
+                                 d_int_opencl__);
       current_statement__ = 243;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+                                 d_real_array_opencl__, p_real_array,
+                                 d_real_opencl__);
       current_statement__ = 244;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
+                                 d_real_array_opencl__, p_real_array,
                                  d_real_array_opencl__);
       current_statement__ = 245;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
+                                 d_real_array_opencl__, p_real_array,
                                  d_vector_opencl__);
       current_statement__ = 246;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
+                                 d_real_array_opencl__, p_real_array,
                                  d_row_vector_opencl__);
       current_statement__ = 247;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+                                 d_real_array_opencl__, p_real_array, p_real);
       current_statement__ = 248;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array_opencl__, p_real_array,
+                                 p_real_array);
       current_statement__ = 249;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array_opencl__, p_real_array,
+                                 p_vector);
       current_statement__ = 250;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array_opencl__, p_real_array,
+                                 p_row_vector);
       current_statement__ = 251;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+                                 d_real_array_opencl__, p_vector,
+                                 d_int_opencl__);
       current_statement__ = 252;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+                                 d_real_array_opencl__, p_vector,
+                                 d_real_opencl__);
       current_statement__ = 253;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
+                                 d_real_array_opencl__, p_vector,
                                  d_real_array_opencl__);
       current_statement__ = 254;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
+                                 d_real_array_opencl__, p_vector,
                                  d_vector_opencl__);
       current_statement__ = 255;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
+                                 d_real_array_opencl__, p_vector,
                                  d_row_vector_opencl__);
       current_statement__ = 256;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+                                 d_real_array_opencl__, p_vector, p_real);
       current_statement__ = 257;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array_opencl__, p_vector,
+                                 p_real_array);
       current_statement__ = 258;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array_opencl__, p_vector, p_vector);
       current_statement__ = 259;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array_opencl__, p_vector,
+                                 p_row_vector);
       current_statement__ = 260;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+                                 d_real_array_opencl__, p_row_vector,
+                                 d_int_opencl__);
       current_statement__ = 261;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+                                 d_real_array_opencl__, p_row_vector,
+                                 d_real_opencl__);
       current_statement__ = 262;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
+                                 d_real_array_opencl__, p_row_vector,
                                  d_real_array_opencl__);
       current_statement__ = 263;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
+                                 d_real_array_opencl__, p_row_vector,
                                  d_vector_opencl__);
       current_statement__ = 264;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
+                                 d_real_array_opencl__, p_row_vector,
                                  d_row_vector_opencl__);
       current_statement__ = 265;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+                                 d_real_array_opencl__, p_row_vector, p_real);
       current_statement__ = 266;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array_opencl__, p_row_vector,
+                                 p_real_array);
       current_statement__ = 267;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array_opencl__, p_row_vector,
+                                 p_vector);
       current_statement__ = 268;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array_opencl__, p_row_vector,
+                                 p_row_vector);
       current_statement__ = 269;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int, d_int);
+                                 d_vector_opencl__, d_int_opencl__,
+                                 d_int_opencl__);
       current_statement__ = 270;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int, d_real);
+                                 d_vector_opencl__, d_int_opencl__,
+                                 d_real_opencl__);
       current_statement__ = 271;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
+                                 d_vector_opencl__, d_int_opencl__,
                                  d_real_array_opencl__);
       current_statement__ = 272;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int, d_vector_opencl__);
+                                 d_vector_opencl__, d_int_opencl__,
+                                 d_vector_opencl__);
       current_statement__ = 273;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
+                                 d_vector_opencl__, d_int_opencl__,
                                  d_row_vector_opencl__);
       current_statement__ = 274;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int, p_real);
+                                 d_vector_opencl__, d_int_opencl__, p_real);
       current_statement__ = 275;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_vector_opencl__, d_int_opencl__,
+                                 p_real_array);
       current_statement__ = 276;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_vector_opencl__, d_int_opencl__, p_vector);
       current_statement__ = 277;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_vector_opencl__, d_int_opencl__,
+                                 p_row_vector);
       current_statement__ = 278;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real, d_int);
+                                 d_vector_opencl__, d_real_opencl__,
+                                 d_int_opencl__);
       current_statement__ = 279;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real, d_real);
+                                 d_vector_opencl__, d_real_opencl__,
+                                 d_real_opencl__);
       current_statement__ = 280;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
+                                 d_vector_opencl__, d_real_opencl__,
                                  d_real_array_opencl__);
       current_statement__ = 281;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real, d_vector_opencl__);
+                                 d_vector_opencl__, d_real_opencl__,
+                                 d_vector_opencl__);
       current_statement__ = 282;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
+                                 d_vector_opencl__, d_real_opencl__,
                                  d_row_vector_opencl__);
       current_statement__ = 283;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real, p_real);
+                                 d_vector_opencl__, d_real_opencl__, p_real);
       current_statement__ = 284;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_vector_opencl__, d_real_opencl__,
+                                 p_real_array);
       current_statement__ = 285;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_vector_opencl__, d_real_opencl__, p_vector);
       current_statement__ = 286;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_vector_opencl__, d_real_opencl__,
+                                 p_row_vector);
       current_statement__ = 287;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_real_array_opencl__,
-                                 d_int);
+                                 d_int_opencl__);
       current_statement__ = 288;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_real_array_opencl__,
-                                 d_real);
+                                 d_real_opencl__);
       current_statement__ = 289;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_real_array_opencl__,
@@ -5056,21 +4295,23 @@ class distributions_model final : public model_base_crtp<distributions_model> {
       current_statement__ = 293;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 294;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 295;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 296;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__, d_int);
+                                 d_vector_opencl__, d_vector_opencl__,
+                                 d_int_opencl__);
       current_statement__ = 297;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__, d_real);
+                                 d_vector_opencl__, d_vector_opencl__,
+                                 d_real_opencl__);
       current_statement__ = 298;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_vector_opencl__,
@@ -5089,23 +4330,23 @@ class distributions_model final : public model_base_crtp<distributions_model> {
       current_statement__ = 302;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 303;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 304;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 305;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_row_vector_opencl__,
-                                 d_int);
+                                 d_int_opencl__);
       current_statement__ = 306;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_row_vector_opencl__,
-                                 d_real);
+                                 d_real_opencl__);
       current_statement__ = 307;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_row_vector_opencl__,
@@ -5125,21 +4366,21 @@ class distributions_model final : public model_base_crtp<distributions_model> {
       current_statement__ = 311;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 312;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 313;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 314;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real, d_int);
+                                 d_vector_opencl__, p_real, d_int_opencl__);
       current_statement__ = 315;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real, d_real);
+                                 d_vector_opencl__, p_real, d_real_opencl__);
       current_statement__ = 316;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_vector_opencl__, p_real,
@@ -5156,222 +4397,191 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_vector_opencl__, p_real, p_real);
       current_statement__ = 320;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_vector_opencl__, p_real, p_real_array);
       current_statement__ = 321;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_vector_opencl__, p_real, p_vector);
       current_statement__ = 322;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_vector_opencl__, p_real, p_row_vector);
       current_statement__ = 323;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+                                 d_vector_opencl__, p_real_array,
+                                 d_int_opencl__);
       current_statement__ = 324;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+                                 d_vector_opencl__, p_real_array,
+                                 d_real_opencl__);
       current_statement__ = 325;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
+                                 d_vector_opencl__, p_real_array,
                                  d_real_array_opencl__);
       current_statement__ = 326;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
+                                 d_vector_opencl__, p_real_array,
                                  d_vector_opencl__);
       current_statement__ = 327;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
+                                 d_vector_opencl__, p_real_array,
                                  d_row_vector_opencl__);
       current_statement__ = 328;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+                                 d_vector_opencl__, p_real_array, p_real);
       current_statement__ = 329;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_vector_opencl__, p_real_array,
+                                 p_real_array);
       current_statement__ = 330;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_vector_opencl__, p_real_array, p_vector);
       current_statement__ = 331;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_vector_opencl__, p_real_array,
+                                 p_row_vector);
       current_statement__ = 332;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+                                 d_vector_opencl__, p_vector, d_int_opencl__);
       current_statement__ = 333;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+                                 d_vector_opencl__, p_vector, d_real_opencl__);
       current_statement__ = 334;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
+                                 d_vector_opencl__, p_vector,
                                  d_real_array_opencl__);
       current_statement__ = 335;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
+                                 d_vector_opencl__, p_vector,
                                  d_vector_opencl__);
       current_statement__ = 336;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
+                                 d_vector_opencl__, p_vector,
                                  d_row_vector_opencl__);
       current_statement__ = 337;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+                                 d_vector_opencl__, p_vector, p_real);
       current_statement__ = 338;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_vector_opencl__, p_vector, p_real_array);
       current_statement__ = 339;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_vector_opencl__, p_vector, p_vector);
       current_statement__ = 340;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_vector_opencl__, p_vector, p_row_vector);
       current_statement__ = 341;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+                                 d_vector_opencl__, p_row_vector,
+                                 d_int_opencl__);
       current_statement__ = 342;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+                                 d_vector_opencl__, p_row_vector,
+                                 d_real_opencl__);
       current_statement__ = 343;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
+                                 d_vector_opencl__, p_row_vector,
                                  d_real_array_opencl__);
       current_statement__ = 344;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
+                                 d_vector_opencl__, p_row_vector,
                                  d_vector_opencl__);
       current_statement__ = 345;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
+                                 d_vector_opencl__, p_row_vector,
                                  d_row_vector_opencl__);
       current_statement__ = 346;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+                                 d_vector_opencl__, p_row_vector, p_real);
       current_statement__ = 347;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_vector_opencl__, p_row_vector,
+                                 p_real_array);
       current_statement__ = 348;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_vector_opencl__, p_row_vector, p_vector);
       current_statement__ = 349;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_vector_opencl__, p_row_vector,
+                                 p_row_vector);
       current_statement__ = 350;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int, d_int);
+                                 d_row_vector_opencl__, d_int_opencl__,
+                                 d_int_opencl__);
       current_statement__ = 351;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int, d_real);
+                                 d_row_vector_opencl__, d_int_opencl__,
+                                 d_real_opencl__);
       current_statement__ = 352;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
+                                 d_row_vector_opencl__, d_int_opencl__,
                                  d_real_array_opencl__);
       current_statement__ = 353;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
+                                 d_row_vector_opencl__, d_int_opencl__,
                                  d_vector_opencl__);
       current_statement__ = 354;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
+                                 d_row_vector_opencl__, d_int_opencl__,
                                  d_row_vector_opencl__);
       current_statement__ = 355;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int, p_real);
+                                 d_row_vector_opencl__, d_int_opencl__,
+                                 p_real);
       current_statement__ = 356;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector_opencl__, d_int_opencl__,
+                                 p_real_array);
       current_statement__ = 357;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector_opencl__, d_int_opencl__,
+                                 p_vector);
       current_statement__ = 358;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector_opencl__, d_int_opencl__,
+                                 p_row_vector);
       current_statement__ = 359;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real, d_int);
+                                 d_row_vector_opencl__, d_real_opencl__,
+                                 d_int_opencl__);
       current_statement__ = 360;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real, d_real);
+                                 d_row_vector_opencl__, d_real_opencl__,
+                                 d_real_opencl__);
       current_statement__ = 361;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
+                                 d_row_vector_opencl__, d_real_opencl__,
                                  d_real_array_opencl__);
       current_statement__ = 362;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
+                                 d_row_vector_opencl__, d_real_opencl__,
                                  d_vector_opencl__);
       current_statement__ = 363;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
+                                 d_row_vector_opencl__, d_real_opencl__,
                                  d_row_vector_opencl__);
       current_statement__ = 364;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real, p_real);
+                                 d_row_vector_opencl__, d_real_opencl__,
+                                 p_real);
       current_statement__ = 365;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector_opencl__, d_real_opencl__,
+                                 p_real_array);
       current_statement__ = 366;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector_opencl__, d_real_opencl__,
+                                 p_vector);
       current_statement__ = 367;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector_opencl__, d_real_opencl__,
+                                 p_row_vector);
       current_statement__ = 368;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__,
-                                 d_real_array_opencl__, d_int);
+                                 d_real_array_opencl__, d_int_opencl__);
       current_statement__ = 369;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__,
-                                 d_real_array_opencl__, d_real);
+                                 d_real_array_opencl__, d_real_opencl__);
       current_statement__ = 370;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__,
@@ -5391,26 +4601,23 @@ class distributions_model final : public model_base_crtp<distributions_model> {
       current_statement__ = 374;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array_opencl__, p_real_array);
       current_statement__ = 375;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array_opencl__, p_vector);
       current_statement__ = 376;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array_opencl__, p_row_vector);
       current_statement__ = 377;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__, d_vector_opencl__,
-                                 d_int);
+                                 d_int_opencl__);
       current_statement__ = 378;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__, d_vector_opencl__,
-                                 d_real);
+                                 d_real_opencl__);
       current_statement__ = 379;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__, d_vector_opencl__,
@@ -5430,23 +4637,23 @@ class distributions_model final : public model_base_crtp<distributions_model> {
       current_statement__ = 383;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 384;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 385;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 386;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__,
-                                 d_row_vector_opencl__, d_int);
+                                 d_row_vector_opencl__, d_int_opencl__);
       current_statement__ = 387;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__,
-                                 d_row_vector_opencl__, d_real);
+                                 d_row_vector_opencl__, d_real_opencl__);
       current_statement__ = 388;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__,
@@ -5466,24 +4673,23 @@ class distributions_model final : public model_base_crtp<distributions_model> {
       current_statement__ = 392;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector_opencl__, p_real_array);
       current_statement__ = 393;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector_opencl__, p_vector);
       current_statement__ = 394;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector_opencl__, p_row_vector);
       current_statement__ = 395;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real, d_int);
+                                 d_row_vector_opencl__, p_real,
+                                 d_int_opencl__);
       current_statement__ = 396;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real, d_real);
+                                 d_row_vector_opencl__, p_real,
+                                 d_real_opencl__);
       current_statement__ = 397;
       transformed_param_real = stan::math::normal_lpdf<false>(
                                  d_row_vector_opencl__, p_real,
@@ -5501,208 +4707,177 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_row_vector_opencl__, p_real, p_real);
       current_statement__ = 401;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector_opencl__, p_real, p_real_array);
       current_statement__ = 402;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector_opencl__, p_real, p_vector);
       current_statement__ = 403;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector_opencl__, p_real, p_row_vector);
       current_statement__ = 404;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+                                 d_row_vector_opencl__, p_real_array,
+                                 d_int_opencl__);
       current_statement__ = 405;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+                                 d_row_vector_opencl__, p_real_array,
+                                 d_real_opencl__);
       current_statement__ = 406;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
+                                 d_row_vector_opencl__, p_real_array,
                                  d_real_array_opencl__);
       current_statement__ = 407;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
+                                 d_row_vector_opencl__, p_real_array,
                                  d_vector_opencl__);
       current_statement__ = 408;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
+                                 d_row_vector_opencl__, p_real_array,
                                  d_row_vector_opencl__);
       current_statement__ = 409;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+                                 d_row_vector_opencl__, p_real_array, p_real);
       current_statement__ = 410;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector_opencl__, p_real_array,
+                                 p_real_array);
       current_statement__ = 411;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector_opencl__, p_real_array,
+                                 p_vector);
       current_statement__ = 412;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector_opencl__, p_real_array,
+                                 p_row_vector);
       current_statement__ = 413;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+                                 d_row_vector_opencl__, p_vector,
+                                 d_int_opencl__);
       current_statement__ = 414;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+                                 d_row_vector_opencl__, p_vector,
+                                 d_real_opencl__);
       current_statement__ = 415;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
+                                 d_row_vector_opencl__, p_vector,
                                  d_real_array_opencl__);
       current_statement__ = 416;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
+                                 d_row_vector_opencl__, p_vector,
                                  d_vector_opencl__);
       current_statement__ = 417;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
+                                 d_row_vector_opencl__, p_vector,
                                  d_row_vector_opencl__);
       current_statement__ = 418;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+                                 d_row_vector_opencl__, p_vector, p_real);
       current_statement__ = 419;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector_opencl__, p_vector,
+                                 p_real_array);
       current_statement__ = 420;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector_opencl__, p_vector, p_vector);
       current_statement__ = 421;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector_opencl__, p_vector,
+                                 p_row_vector);
       current_statement__ = 422;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+                                 d_row_vector_opencl__, p_row_vector,
+                                 d_int_opencl__);
       current_statement__ = 423;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+                                 d_row_vector_opencl__, p_row_vector,
+                                 d_real_opencl__);
       current_statement__ = 424;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
+                                 d_row_vector_opencl__, p_row_vector,
                                  d_real_array_opencl__);
       current_statement__ = 425;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
+                                 d_row_vector_opencl__, p_row_vector,
                                  d_vector_opencl__);
       current_statement__ = 426;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
+                                 d_row_vector_opencl__, p_row_vector,
                                  d_row_vector_opencl__);
       current_statement__ = 427;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+                                 d_row_vector_opencl__, p_row_vector, p_real);
       current_statement__ = 428;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector_opencl__, p_row_vector,
+                                 p_real_array);
       current_statement__ = 429;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector_opencl__, p_row_vector,
+                                 p_vector);
       current_statement__ = 430;
       transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector_opencl__, p_row_vector,
+                                 p_row_vector);
       current_statement__ = 431;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_int_opencl__, d_int_opencl__);
       current_statement__ = 432;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_int_opencl__, d_real_opencl__);
       current_statement__ = 433;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_int_opencl__, d_real_array_opencl__);
       current_statement__ = 434;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_int_opencl__, d_vector_opencl__);
       current_statement__ = 435;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_int_opencl__, d_row_vector_opencl__);
       current_statement__ = 436;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_int_opencl__, p_real);
       current_statement__ = 437;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_int_opencl__, p_real_array);
       current_statement__ = 438;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_int_opencl__, p_vector);
       current_statement__ = 439;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_int_opencl__, p_row_vector);
       current_statement__ = 440;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_real_opencl__, d_int_opencl__);
       current_statement__ = 441;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_real_opencl__, d_real_opencl__);
       current_statement__ = 442;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_real_opencl__, d_real_array_opencl__);
       current_statement__ = 443;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_real_opencl__, d_vector_opencl__);
       current_statement__ = 444;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_real_opencl__, d_row_vector_opencl__);
       current_statement__ = 445;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_real_opencl__, p_real);
       current_statement__ = 446;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_real_opencl__, p_real_array);
       current_statement__ = 447;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_real_opencl__, p_vector);
       current_statement__ = 448;
-      transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real,
+                                 d_real_opencl__, p_row_vector);
       current_statement__ = 449;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, d_int);
+                                 d_real_array_opencl__, d_int_opencl__);
       current_statement__ = 450;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, d_real);
+                                 d_real_array_opencl__, d_real_opencl__);
       current_statement__ = 451;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
                                  d_real_array_opencl__, d_real_array_opencl__);
@@ -5717,22 +4892,19 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real_array_opencl__, p_real);
       current_statement__ = 455;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array_opencl__, p_real_array);
       current_statement__ = 456;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array_opencl__, p_vector);
       current_statement__ = 457;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array_opencl__, p_row_vector);
       current_statement__ = 458;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, d_int);
+                                 d_vector_opencl__, d_int_opencl__);
       current_statement__ = 459;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, d_real);
+                                 d_vector_opencl__, d_real_opencl__);
       current_statement__ = 460;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
                                  d_vector_opencl__, d_real_array_opencl__);
@@ -5747,22 +4919,19 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_vector_opencl__, p_real);
       current_statement__ = 464;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_vector_opencl__, p_real_array);
       current_statement__ = 465;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_vector_opencl__, p_vector);
       current_statement__ = 466;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_vector_opencl__, p_row_vector);
       current_statement__ = 467;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, d_int);
+                                 d_row_vector_opencl__, d_int_opencl__);
       current_statement__ = 468;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, d_real);
+                                 d_row_vector_opencl__, d_real_opencl__);
       current_statement__ = 469;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
                                  d_row_vector_opencl__, d_real_array_opencl__);
@@ -5777,22 +4946,19 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_row_vector_opencl__, p_real);
       current_statement__ = 473;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector_opencl__, p_real_array);
       current_statement__ = 474;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector_opencl__, p_vector);
       current_statement__ = 475;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector_opencl__, p_row_vector);
       current_statement__ = 476;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 d_int);
+                                 d_int_opencl__);
       current_statement__ = 477;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 d_real);
+                                 d_real_opencl__);
       current_statement__ = 478;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
                                  d_real_array_opencl__);
@@ -5807,1209 +4973,827 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  p_real);
       current_statement__ = 482;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 483;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 484;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 485;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+                                 p_real_array, d_int_opencl__);
       current_statement__ = 486;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+                                 p_real_array, d_real_opencl__);
       current_statement__ = 487;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+                                 p_real_array, d_real_array_opencl__);
       current_statement__ = 488;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+                                 p_real_array, d_vector_opencl__);
       current_statement__ = 489;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+                                 p_real_array, d_row_vector_opencl__);
       current_statement__ = 490;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+                                 p_real_array, p_real);
       current_statement__ = 491;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array, p_real_array);
       current_statement__ = 492;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_real_array, p_vector);
       current_statement__ = 493;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_real_array, p_row_vector);
       current_statement__ = 494;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+                                 p_vector, d_int_opencl__);
       current_statement__ = 495;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+                                 p_vector, d_real_opencl__);
       current_statement__ = 496;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+                                 p_vector, d_real_array_opencl__);
       current_statement__ = 497;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+                                 p_vector, d_vector_opencl__);
       current_statement__ = 498;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+                                 p_vector, d_row_vector_opencl__);
       current_statement__ = 499;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+                                 p_vector, p_real);
       current_statement__ = 500;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_vector, p_real_array);
       current_statement__ = 501;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector, p_vector);
       current_statement__ = 502;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_vector, p_row_vector);
       current_statement__ = 503;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+                                 p_row_vector, d_int_opencl__);
       current_statement__ = 504;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+                                 p_row_vector, d_real_opencl__);
       current_statement__ = 505;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+                                 p_row_vector, d_real_array_opencl__);
       current_statement__ = 506;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+                                 p_row_vector, d_vector_opencl__);
       current_statement__ = 507;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+                                 p_row_vector, d_row_vector_opencl__);
       current_statement__ = 508;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+                                 p_row_vector, p_real);
       current_statement__ = 509;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_row_vector, p_real_array);
       current_statement__ = 510;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_row_vector, p_vector);
       current_statement__ = 511;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector, p_row_vector);
       current_statement__ = 512;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int_opencl__, d_int_opencl__);
       current_statement__ = 513;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int_opencl__, d_real_opencl__);
       current_statement__ = 514;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int_opencl__, d_real_array_opencl__);
       current_statement__ = 515;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int_opencl__, d_vector_opencl__);
       current_statement__ = 516;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int_opencl__, d_row_vector_opencl__);
       current_statement__ = 517;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int_opencl__, p_real);
       current_statement__ = 518;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int_opencl__, p_real_array);
       current_statement__ = 519;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int_opencl__, p_vector);
       current_statement__ = 520;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int_opencl__, p_row_vector);
       current_statement__ = 521;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_opencl__, d_int_opencl__);
       current_statement__ = 522;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_opencl__, d_real_opencl__);
       current_statement__ = 523;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_opencl__, d_real_array_opencl__);
       current_statement__ = 524;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_opencl__, d_vector_opencl__);
       current_statement__ = 525;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_opencl__, d_row_vector_opencl__);
       current_statement__ = 526;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_opencl__, p_real);
       current_statement__ = 527;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_opencl__, p_real_array);
       current_statement__ = 528;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_opencl__, p_vector);
       current_statement__ = 529;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_opencl__, p_row_vector);
       current_statement__ = 530;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array_opencl__, d_int_opencl__);
       current_statement__ = 531;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array_opencl__, d_real_opencl__);
       current_statement__ = 532;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_real_array_opencl__, d_real_array_opencl__);
       current_statement__ = 533;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_real_array_opencl__, d_vector_opencl__);
       current_statement__ = 534;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_real_array_opencl__, d_row_vector_opencl__);
       current_statement__ = 535;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_real_array_opencl__, p_real);
       current_statement__ = 536;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array_opencl__, p_real_array);
       current_statement__ = 537;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array_opencl__, p_vector);
       current_statement__ = 538;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array_opencl__, p_row_vector);
       current_statement__ = 539;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector_opencl__, d_int_opencl__);
       current_statement__ = 540;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector_opencl__, d_real_opencl__);
       current_statement__ = 541;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_vector_opencl__, d_real_array_opencl__);
       current_statement__ = 542;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_vector_opencl__, d_vector_opencl__);
       current_statement__ = 543;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_vector_opencl__, d_row_vector_opencl__);
       current_statement__ = 544;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_vector_opencl__, p_real);
       current_statement__ = 545;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector_opencl__, p_real_array);
       current_statement__ = 546;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector_opencl__, p_vector);
       current_statement__ = 547;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector_opencl__, p_row_vector);
       current_statement__ = 548;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector_opencl__, d_int_opencl__);
       current_statement__ = 549;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector_opencl__, d_real_opencl__);
       current_statement__ = 550;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_row_vector_opencl__, d_real_array_opencl__);
       current_statement__ = 551;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_row_vector_opencl__, d_vector_opencl__);
       current_statement__ = 552;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_row_vector_opencl__, d_row_vector_opencl__);
       current_statement__ = 553;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_row_vector_opencl__, p_real);
       current_statement__ = 554;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector_opencl__, p_real_array);
       current_statement__ = 555;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector_opencl__, p_vector);
       current_statement__ = 556;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector_opencl__, p_row_vector);
       current_statement__ = 557;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, d_int_opencl__);
       current_statement__ = 558;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, d_real_opencl__);
       current_statement__ = 559;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  p_real, d_real_array_opencl__);
       current_statement__ = 560;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  p_real, d_vector_opencl__);
       current_statement__ = 561;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  p_real, d_row_vector_opencl__);
       current_statement__ = 562;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  p_real, p_real);
       current_statement__ = 563;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, p_real_array);
       current_statement__ = 564;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, p_vector);
       current_statement__ = 565;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, p_row_vector);
       current_statement__ = 566;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_int_opencl__);
       current_statement__ = 567;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_real_opencl__);
       current_statement__ = 568;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_real_array_opencl__);
       current_statement__ = 569;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_vector_opencl__);
       current_statement__ = 570;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_row_vector_opencl__);
       current_statement__ = 571;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, p_real);
       current_statement__ = 572;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, p_real_array);
       current_statement__ = 573;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, p_vector);
       current_statement__ = 574;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, p_row_vector);
       current_statement__ = 575;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_int_opencl__);
       current_statement__ = 576;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_real_opencl__);
       current_statement__ = 577;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_real_array_opencl__);
       current_statement__ = 578;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_vector_opencl__);
       current_statement__ = 579;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_row_vector_opencl__);
       current_statement__ = 580;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, p_real);
       current_statement__ = 581;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, p_real_array);
       current_statement__ = 582;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, p_vector);
       current_statement__ = 583;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, p_row_vector);
       current_statement__ = 584;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_int_opencl__);
       current_statement__ = 585;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_real_opencl__);
       current_statement__ = 586;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_real_array_opencl__);
       current_statement__ = 587;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_vector_opencl__);
       current_statement__ = 588;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_row_vector_opencl__);
       current_statement__ = 589;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, p_real);
       current_statement__ = 590;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, p_real_array);
       current_statement__ = 591;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, p_vector);
       current_statement__ = 592;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, p_row_vector);
       current_statement__ = 593;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int_opencl__, d_int_opencl__);
       current_statement__ = 594;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int_opencl__, d_real_opencl__);
       current_statement__ = 595;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int_opencl__, d_real_array_opencl__);
       current_statement__ = 596;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int_opencl__, d_vector_opencl__);
       current_statement__ = 597;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int_opencl__, d_row_vector_opencl__);
       current_statement__ = 598;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int_opencl__, p_real);
       current_statement__ = 599;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int_opencl__, p_real_array);
       current_statement__ = 600;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int_opencl__, p_vector);
       current_statement__ = 601;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int_opencl__, p_row_vector);
       current_statement__ = 602;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_opencl__, d_int_opencl__);
       current_statement__ = 603;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_opencl__, d_real_opencl__);
       current_statement__ = 604;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_opencl__, d_real_array_opencl__);
       current_statement__ = 605;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_opencl__, d_vector_opencl__);
       current_statement__ = 606;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_opencl__, d_row_vector_opencl__);
       current_statement__ = 607;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_opencl__, p_real);
       current_statement__ = 608;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_opencl__, p_real_array);
       current_statement__ = 609;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_opencl__, p_vector);
       current_statement__ = 610;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_opencl__, p_row_vector);
       current_statement__ = 611;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array_opencl__, d_int_opencl__);
       current_statement__ = 612;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array_opencl__, d_real_opencl__);
       current_statement__ = 613;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
                                  d_real_array_opencl__, d_real_array_opencl__);
       current_statement__ = 614;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
                                  d_real_array_opencl__, d_vector_opencl__);
       current_statement__ = 615;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
                                  d_real_array_opencl__, d_row_vector_opencl__);
       current_statement__ = 616;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
                                  d_real_array_opencl__, p_real);
       current_statement__ = 617;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array_opencl__, p_real_array);
       current_statement__ = 618;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array_opencl__, p_vector);
       current_statement__ = 619;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array_opencl__, p_row_vector);
       current_statement__ = 620;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector_opencl__, d_int_opencl__);
       current_statement__ = 621;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector_opencl__, d_real_opencl__);
       current_statement__ = 622;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
                                  d_vector_opencl__, d_real_array_opencl__);
       current_statement__ = 623;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
                                  d_vector_opencl__, d_vector_opencl__);
       current_statement__ = 624;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
                                  d_vector_opencl__, d_row_vector_opencl__);
       current_statement__ = 625;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
                                  d_vector_opencl__, p_real);
       current_statement__ = 626;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector_opencl__, p_real_array);
       current_statement__ = 627;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector_opencl__, p_vector);
       current_statement__ = 628;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector_opencl__, p_row_vector);
       current_statement__ = 629;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector_opencl__, d_int_opencl__);
       current_statement__ = 630;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector_opencl__, d_real_opencl__);
       current_statement__ = 631;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
                                  d_row_vector_opencl__, d_real_array_opencl__);
       current_statement__ = 632;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
                                  d_row_vector_opencl__, d_vector_opencl__);
       current_statement__ = 633;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
                                  d_row_vector_opencl__, d_row_vector_opencl__);
       current_statement__ = 634;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
                                  d_row_vector_opencl__, p_real);
       current_statement__ = 635;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector_opencl__, p_real_array);
       current_statement__ = 636;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector_opencl__, p_vector);
       current_statement__ = 637;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector_opencl__, p_row_vector);
       current_statement__ = 638;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_int_opencl__);
       current_statement__ = 639;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_real_opencl__);
       current_statement__ = 640;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_real_array_opencl__);
       current_statement__ = 641;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_vector_opencl__);
       current_statement__ = 642;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_row_vector_opencl__);
       current_statement__ = 643;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, p_real);
       current_statement__ = 644;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, p_real_array);
       current_statement__ = 645;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, p_vector);
       current_statement__ = 646;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, p_row_vector);
       current_statement__ = 647;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_int_opencl__);
       current_statement__ = 648;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_real_opencl__);
       current_statement__ = 649;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_real_array_opencl__);
       current_statement__ = 650;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_vector_opencl__);
       current_statement__ = 651;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_row_vector_opencl__);
       current_statement__ = 652;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, p_real);
       current_statement__ = 653;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, p_real_array);
       current_statement__ = 654;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, p_vector);
       current_statement__ = 655;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, p_row_vector);
       current_statement__ = 656;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_int_opencl__);
       current_statement__ = 657;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_real_opencl__);
       current_statement__ = 658;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_real_array_opencl__);
       current_statement__ = 659;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_vector_opencl__);
       current_statement__ = 660;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_row_vector_opencl__);
       current_statement__ = 661;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, p_real);
       current_statement__ = 662;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, p_real_array);
       current_statement__ = 663;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, p_vector);
       current_statement__ = 664;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, p_row_vector);
       current_statement__ = 665;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_int_opencl__);
       current_statement__ = 666;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_real_opencl__);
       current_statement__ = 667;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_real_array_opencl__);
       current_statement__ = 668;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_vector_opencl__);
       current_statement__ = 669;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_row_vector_opencl__);
       current_statement__ = 670;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, p_real);
       current_statement__ = 671;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, p_real_array);
       current_statement__ = 672;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, p_vector);
       current_statement__ = 673;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, p_row_vector);
       current_statement__ = 674;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int_opencl__, d_int_opencl__);
       current_statement__ = 675;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int_opencl__, d_real_opencl__);
       current_statement__ = 676;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int_opencl__, d_real_array_opencl__);
       current_statement__ = 677;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int_opencl__, d_vector_opencl__);
       current_statement__ = 678;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int_opencl__, d_row_vector_opencl__);
       current_statement__ = 679;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int_opencl__, p_real);
       current_statement__ = 680;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int_opencl__, p_real_array);
       current_statement__ = 681;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int_opencl__, p_vector);
       current_statement__ = 682;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int_opencl__, p_row_vector);
       current_statement__ = 683;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_opencl__, d_int_opencl__);
       current_statement__ = 684;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_opencl__, d_real_opencl__);
       current_statement__ = 685;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_opencl__, d_real_array_opencl__);
       current_statement__ = 686;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_opencl__, d_vector_opencl__);
       current_statement__ = 687;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_opencl__, d_row_vector_opencl__);
       current_statement__ = 688;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_opencl__, p_real);
       current_statement__ = 689;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_opencl__, p_real_array);
       current_statement__ = 690;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_opencl__, p_vector);
       current_statement__ = 691;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_opencl__, p_row_vector);
       current_statement__ = 692;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array_opencl__, d_int_opencl__);
       current_statement__ = 693;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array_opencl__, d_real_opencl__);
       current_statement__ = 694;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_real_array_opencl__, d_real_array_opencl__);
       current_statement__ = 695;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_real_array_opencl__, d_vector_opencl__);
       current_statement__ = 696;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_real_array_opencl__, d_row_vector_opencl__);
       current_statement__ = 697;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_real_array_opencl__, p_real);
       current_statement__ = 698;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array_opencl__, p_real_array);
       current_statement__ = 699;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array_opencl__, p_vector);
       current_statement__ = 700;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array_opencl__, p_row_vector);
       current_statement__ = 701;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector_opencl__, d_int_opencl__);
       current_statement__ = 702;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector_opencl__, d_real_opencl__);
       current_statement__ = 703;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_vector_opencl__, d_real_array_opencl__);
       current_statement__ = 704;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_vector_opencl__, d_vector_opencl__);
       current_statement__ = 705;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_vector_opencl__, d_row_vector_opencl__);
       current_statement__ = 706;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_vector_opencl__, p_real);
       current_statement__ = 707;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector_opencl__, p_real_array);
       current_statement__ = 708;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector_opencl__, p_vector);
       current_statement__ = 709;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector_opencl__, p_row_vector);
       current_statement__ = 710;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector_opencl__, d_int_opencl__);
       current_statement__ = 711;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector_opencl__, d_real_opencl__);
       current_statement__ = 712;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_row_vector_opencl__, d_real_array_opencl__);
       current_statement__ = 713;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_row_vector_opencl__, d_vector_opencl__);
       current_statement__ = 714;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_row_vector_opencl__, d_row_vector_opencl__);
       current_statement__ = 715;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_row_vector_opencl__, p_real);
       current_statement__ = 716;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector_opencl__, p_real_array);
       current_statement__ = 717;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector_opencl__, p_vector);
       current_statement__ = 718;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector_opencl__, p_row_vector);
       current_statement__ = 719;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, d_int_opencl__);
       current_statement__ = 720;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, d_real_opencl__);
       current_statement__ = 721;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  p_real, d_real_array_opencl__);
       current_statement__ = 722;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  p_real, d_vector_opencl__);
       current_statement__ = 723;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  p_real, d_row_vector_opencl__);
       current_statement__ = 724;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  p_real, p_real);
       current_statement__ = 725;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, p_real_array);
       current_statement__ = 726;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, p_vector);
       current_statement__ = 727;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, p_row_vector);
       current_statement__ = 728;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_int_opencl__);
       current_statement__ = 729;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_real_opencl__);
       current_statement__ = 730;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_real_array_opencl__);
       current_statement__ = 731;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_vector_opencl__);
       current_statement__ = 732;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_row_vector_opencl__);
       current_statement__ = 733;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, p_real);
       current_statement__ = 734;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, p_real_array);
       current_statement__ = 735;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, p_vector);
       current_statement__ = 736;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, p_row_vector);
       current_statement__ = 737;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_int_opencl__);
       current_statement__ = 738;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_real_opencl__);
       current_statement__ = 739;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_real_array_opencl__);
       current_statement__ = 740;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_vector_opencl__);
       current_statement__ = 741;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_row_vector_opencl__);
       current_statement__ = 742;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, p_real);
       current_statement__ = 743;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, p_real_array);
       current_statement__ = 744;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, p_vector);
       current_statement__ = 745;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, p_row_vector);
       current_statement__ = 746;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_int_opencl__);
       current_statement__ = 747;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_real_opencl__);
       current_statement__ = 748;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_real_array_opencl__);
       current_statement__ = 749;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_vector_opencl__);
       current_statement__ = 750;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_row_vector_opencl__);
       current_statement__ = 751;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, p_real);
       current_statement__ = 752;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, p_real_array);
       current_statement__ = 753;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, p_vector);
       current_statement__ = 754;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, p_row_vector);
       {
         current_statement__ = 755;
         lp_accum__.add(stan::math::normal_lpdf<propto__>(y_p, 0, 1));
       }
-      d_int_array_opencl__.wait_for_read_write_events();
-      d_real_array_opencl__.wait_for_read_write_events();
-      d_row_vector_opencl__.wait_for_read_write_events();
-      d_vector_opencl__.wait_for_read_write_events();
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
     }
@@ -7101,52 +5885,49 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  p_real);
       current_statement__ = 11;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 12;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 13;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 14;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 15;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 16;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 17;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, d_int);
+                                 d_int_array, d_int);
       current_statement__ = 18;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, d_real);
+                                 d_int_array, d_real);
       current_statement__ = 19;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, p_real);
+                                 d_int_array, p_real);
       current_statement__ = 20;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, d_vector_opencl__);
+                                 d_int_array, d_vector);
       current_statement__ = 21;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_int_array, p_vector);
       current_statement__ = 22;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, d_row_vector_opencl__);
+                                 d_int_array, d_row_vector);
       current_statement__ = 23;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_int_array, p_row_vector);
       current_statement__ = 24;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__, d_real_array_opencl__);
+                                 d_int_array, d_real_array);
       current_statement__ = 25;
       transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
-                                 d_int_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_int_array, p_real_array);
       current_statement__ = 26;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
                                  d_int);
@@ -7155,25 +5936,25 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 28;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 29;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 30;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 31;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
                                  p_real);
       current_statement__ = 32;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 33;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 34;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 35;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
                                  d_int);
@@ -7182,115 +5963,106 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 37;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 38;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 39;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 40;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
                                  p_real);
       current_statement__ = 41;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 42;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 43;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 44;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, d_int);
+                                 d_real_array, d_int);
       current_statement__ = 45;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, d_real);
+                                 d_real_array, d_real);
       current_statement__ = 46;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, d_real_array_opencl__);
+                                 d_real_array, d_real_array);
       current_statement__ = 47;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, d_vector_opencl__);
+                                 d_real_array, d_vector);
       current_statement__ = 48;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+                                 d_real_array, d_row_vector);
       current_statement__ = 49;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__, p_real);
+                                 d_real_array, p_real);
       current_statement__ = 50;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array, p_real_array);
       current_statement__ = 51;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array, p_vector);
       current_statement__ = 52;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array, p_row_vector);
       current_statement__ = 53;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, d_int);
+                                 d_vector, d_int);
       current_statement__ = 54;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, d_real);
+                                 d_vector, d_real);
       current_statement__ = 55;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, d_real_array_opencl__);
+                                 d_vector, d_real_array);
       current_statement__ = 56;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, d_vector_opencl__);
+                                 d_vector, d_vector);
       current_statement__ = 57;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, d_row_vector_opencl__);
+                                 d_vector, d_row_vector);
       current_statement__ = 58;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__, p_real);
+                                 d_vector, p_real);
       current_statement__ = 59;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_vector, p_real_array);
       current_statement__ = 60;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_vector, p_vector);
       current_statement__ = 61;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_vector, p_row_vector);
       current_statement__ = 62;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, d_int);
+                                 d_row_vector, d_int);
       current_statement__ = 63;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, d_real);
+                                 d_row_vector, d_real);
       current_statement__ = 64;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+                                 d_row_vector, d_real_array);
       current_statement__ = 65;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, d_vector_opencl__);
+                                 d_row_vector, d_vector);
       current_statement__ = 66;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+                                 d_row_vector, d_row_vector);
       current_statement__ = 67;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__, p_real);
+                                 d_row_vector, p_real);
       current_statement__ = 68;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector, p_real_array);
       current_statement__ = 69;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector, p_vector);
       current_statement__ = 70;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector, p_row_vector);
       current_statement__ = 71;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
                                  d_int);
@@ -7299,130 +6071,106 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 73;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 74;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 75;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 76;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
                                  p_real);
       current_statement__ = 77;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 78;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 79;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 80;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+                                 p_real_array, d_int);
       current_statement__ = 81;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+                                 p_real_array, d_real);
       current_statement__ = 82;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+                                 p_real_array, d_real_array);
       current_statement__ = 83;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+                                 p_real_array, d_vector);
       current_statement__ = 84;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+                                 p_real_array, d_row_vector);
       current_statement__ = 85;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+                                 p_real_array, p_real);
       current_statement__ = 86;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array, p_real_array);
       current_statement__ = 87;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_real_array, p_vector);
       current_statement__ = 88;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_real_array, p_row_vector);
       current_statement__ = 89;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+                                 p_vector, d_int);
       current_statement__ = 90;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+                                 p_vector, d_real);
       current_statement__ = 91;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+                                 p_vector, d_real_array);
       current_statement__ = 92;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+                                 p_vector, d_vector);
       current_statement__ = 93;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+                                 p_vector, d_row_vector);
       current_statement__ = 94;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+                                 p_vector, p_real);
       current_statement__ = 95;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_vector, p_real_array);
       current_statement__ = 96;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector, p_vector);
       current_statement__ = 97;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_vector, p_row_vector);
       current_statement__ = 98;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+                                 p_row_vector, d_int);
       current_statement__ = 99;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+                                 p_row_vector, d_real);
       current_statement__ = 100;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+                                 p_row_vector, d_real_array);
       current_statement__ = 101;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+                                 p_row_vector, d_vector);
       current_statement__ = 102;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+                                 p_row_vector, d_row_vector);
       current_statement__ = 103;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+                                 p_row_vector, p_real);
       current_statement__ = 104;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_row_vector, p_real_array);
       current_statement__ = 105;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_row_vector, p_vector);
       current_statement__ = 106;
       transformed_param_real = stan::math::normal_lpdf<false>(d_int,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector, p_row_vector);
       current_statement__ = 107;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
                                  d_int);
@@ -7431,25 +6179,25 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 109;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 110;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 111;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 112;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
                                  p_real);
       current_statement__ = 113;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 114;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 115;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 116;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
                                  d_int);
@@ -7458,115 +6206,106 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 118;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 119;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 120;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 121;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
                                  p_real);
       current_statement__ = 122;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 123;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 124;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 125;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_int);
+                                 d_real_array, d_int);
       current_statement__ = 126;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_real);
+                                 d_real_array, d_real);
       current_statement__ = 127;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_real_array_opencl__);
+                                 d_real_array, d_real_array);
       current_statement__ = 128;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_vector_opencl__);
+                                 d_real_array, d_vector);
       current_statement__ = 129;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+                                 d_real_array, d_row_vector);
       current_statement__ = 130;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__, p_real);
+                                 d_real_array, p_real);
       current_statement__ = 131;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array, p_real_array);
       current_statement__ = 132;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array, p_vector);
       current_statement__ = 133;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array, p_row_vector);
       current_statement__ = 134;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_int);
+                                 d_vector, d_int);
       current_statement__ = 135;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_real);
+                                 d_vector, d_real);
       current_statement__ = 136;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_real_array_opencl__);
+                                 d_vector, d_real_array);
       current_statement__ = 137;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_vector_opencl__);
+                                 d_vector, d_vector);
       current_statement__ = 138;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, d_row_vector_opencl__);
+                                 d_vector, d_row_vector);
       current_statement__ = 139;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__, p_real);
+                                 d_vector, p_real);
       current_statement__ = 140;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_vector, p_real_array);
       current_statement__ = 141;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_vector, p_vector);
       current_statement__ = 142;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_vector, p_row_vector);
       current_statement__ = 143;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_int);
+                                 d_row_vector, d_int);
       current_statement__ = 144;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_real);
+                                 d_row_vector, d_real);
       current_statement__ = 145;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+                                 d_row_vector, d_real_array);
       current_statement__ = 146;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_vector_opencl__);
+                                 d_row_vector, d_vector);
       current_statement__ = 147;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+                                 d_row_vector, d_row_vector);
       current_statement__ = 148;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__, p_real);
+                                 d_row_vector, p_real);
       current_statement__ = 149;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector, p_real_array);
       current_statement__ = 150;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector, p_vector);
       current_statement__ = 151;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector, p_row_vector);
       current_statement__ = 152;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
                                  d_int);
@@ -7575,1153 +6314,835 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 154;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 155;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 156;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 157;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
                                  p_real);
       current_statement__ = 158;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 159;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 160;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 161;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+                                 p_real_array, d_int);
       current_statement__ = 162;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+                                 p_real_array, d_real);
       current_statement__ = 163;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+                                 p_real_array, d_real_array);
       current_statement__ = 164;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+                                 p_real_array, d_vector);
       current_statement__ = 165;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+                                 p_real_array, d_row_vector);
       current_statement__ = 166;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+                                 p_real_array, p_real);
       current_statement__ = 167;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array, p_real_array);
       current_statement__ = 168;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_real_array, p_vector);
       current_statement__ = 169;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_real_array, p_row_vector);
       current_statement__ = 170;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+                                 p_vector, d_int);
       current_statement__ = 171;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+                                 p_vector, d_real);
       current_statement__ = 172;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+                                 p_vector, d_real_array);
       current_statement__ = 173;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+                                 p_vector, d_vector);
       current_statement__ = 174;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+                                 p_vector, d_row_vector);
       current_statement__ = 175;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+                                 p_vector, p_real);
       current_statement__ = 176;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_vector, p_real_array);
       current_statement__ = 177;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector, p_vector);
       current_statement__ = 178;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_vector, p_row_vector);
       current_statement__ = 179;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+                                 p_row_vector, d_int);
       current_statement__ = 180;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+                                 p_row_vector, d_real);
       current_statement__ = 181;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+                                 p_row_vector, d_real_array);
       current_statement__ = 182;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+                                 p_row_vector, d_vector);
       current_statement__ = 183;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+                                 p_row_vector, d_row_vector);
       current_statement__ = 184;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+                                 p_row_vector, p_real);
       current_statement__ = 185;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_row_vector, p_real_array);
       current_statement__ = 186;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_row_vector, p_vector);
       current_statement__ = 187;
       transformed_param_real = stan::math::normal_lpdf<false>(d_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector, p_row_vector);
       current_statement__ = 188;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, d_int);
       current_statement__ = 189;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, d_real);
       current_statement__ = 190;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, d_real_array);
       current_statement__ = 191;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, d_vector);
       current_statement__ = 192;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, d_row_vector);
       current_statement__ = 193;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, p_real);
       current_statement__ = 194;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, p_real_array);
       current_statement__ = 195;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, p_vector);
       current_statement__ = 196;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_int, p_row_vector);
       current_statement__ = 197;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, d_int);
       current_statement__ = 198;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, d_real);
       current_statement__ = 199;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, d_real_array);
       current_statement__ = 200;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, d_vector);
       current_statement__ = 201;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, d_row_vector);
       current_statement__ = 202;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, p_real);
       current_statement__ = 203;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, p_real_array);
       current_statement__ = 204;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, p_vector);
       current_statement__ = 205;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real, p_row_vector);
       current_statement__ = 206;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, d_int);
       current_statement__ = 207;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, d_real);
       current_statement__ = 208;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, d_real_array);
       current_statement__ = 209;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, d_vector);
       current_statement__ = 210;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, d_row_vector);
       current_statement__ = 211;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, p_real);
       current_statement__ = 212;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, p_real_array);
       current_statement__ = 213;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, p_vector);
       current_statement__ = 214;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_real_array, p_row_vector);
       current_statement__ = 215;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, d_int);
       current_statement__ = 216;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, d_real);
       current_statement__ = 217;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, d_real_array);
       current_statement__ = 218;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, d_vector);
       current_statement__ = 219;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, d_row_vector);
       current_statement__ = 220;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, p_real);
       current_statement__ = 221;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, p_real_array);
       current_statement__ = 222;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, p_vector);
       current_statement__ = 223;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_vector, p_row_vector);
       current_statement__ = 224;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, d_int);
       current_statement__ = 225;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, d_real);
       current_statement__ = 226;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, d_real_array);
       current_statement__ = 227;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, d_vector);
       current_statement__ = 228;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, d_row_vector);
       current_statement__ = 229;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, p_real);
       current_statement__ = 230;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, p_real_array);
       current_statement__ = 231;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, p_vector);
       current_statement__ = 232;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 d_row_vector, p_row_vector);
       current_statement__ = 233;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, d_int);
       current_statement__ = 234;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, d_real);
       current_statement__ = 235;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, d_real_array);
       current_statement__ = 236;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, d_vector);
       current_statement__ = 237;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, d_row_vector);
       current_statement__ = 238;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, p_real);
       current_statement__ = 239;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, p_real_array);
       current_statement__ = 240;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, p_vector);
       current_statement__ = 241;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real, p_row_vector);
       current_statement__ = 242;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, d_int);
       current_statement__ = 243;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, d_real);
       current_statement__ = 244;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, d_real_array);
       current_statement__ = 245;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, d_vector);
       current_statement__ = 246;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, d_row_vector);
       current_statement__ = 247;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, p_real);
       current_statement__ = 248;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, p_real_array);
       current_statement__ = 249;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, p_vector);
       current_statement__ = 250;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_real_array, p_row_vector);
       current_statement__ = 251;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, d_int);
       current_statement__ = 252;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, d_real);
       current_statement__ = 253;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, d_real_array);
       current_statement__ = 254;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, d_vector);
       current_statement__ = 255;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, d_row_vector);
       current_statement__ = 256;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, p_real);
       current_statement__ = 257;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, p_real_array);
       current_statement__ = 258;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, p_vector);
       current_statement__ = 259;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_vector, p_row_vector);
       current_statement__ = 260;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, d_int);
       current_statement__ = 261;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, d_real);
       current_statement__ = 262;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, d_real_array);
       current_statement__ = 263;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, d_vector);
       current_statement__ = 264;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, d_row_vector);
       current_statement__ = 265;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, p_real);
       current_statement__ = 266;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, p_real_array);
       current_statement__ = 267;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, p_vector);
       current_statement__ = 268;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_real_array,
+                                 p_row_vector, p_row_vector);
       current_statement__ = 269;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, d_int);
       current_statement__ = 270;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, d_real);
       current_statement__ = 271;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, d_real_array);
       current_statement__ = 272;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, d_vector);
       current_statement__ = 273;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, d_row_vector);
       current_statement__ = 274;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, p_real);
       current_statement__ = 275;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, p_real_array);
       current_statement__ = 276;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, p_vector);
       current_statement__ = 277;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_int, p_row_vector);
       current_statement__ = 278;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, d_int);
       current_statement__ = 279;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, d_real);
       current_statement__ = 280;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, d_real_array);
       current_statement__ = 281;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, d_vector);
       current_statement__ = 282;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, d_row_vector);
       current_statement__ = 283;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, p_real);
       current_statement__ = 284;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, p_real_array);
       current_statement__ = 285;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, p_vector);
       current_statement__ = 286;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real, p_row_vector);
       current_statement__ = 287;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, d_int);
       current_statement__ = 288;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, d_real);
       current_statement__ = 289;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, d_real_array);
       current_statement__ = 290;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, d_vector);
       current_statement__ = 291;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, d_row_vector);
       current_statement__ = 292;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, p_real);
       current_statement__ = 293;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, p_real_array);
       current_statement__ = 294;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, p_vector);
       current_statement__ = 295;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_real_array, p_row_vector);
       current_statement__ = 296;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, d_int);
       current_statement__ = 297;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, d_real);
       current_statement__ = 298;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, d_real_array);
       current_statement__ = 299;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, d_vector);
       current_statement__ = 300;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, d_row_vector);
       current_statement__ = 301;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, p_real);
       current_statement__ = 302;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, p_real_array);
       current_statement__ = 303;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, p_vector);
       current_statement__ = 304;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_vector, p_row_vector);
       current_statement__ = 305;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, d_int);
       current_statement__ = 306;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, d_real);
       current_statement__ = 307;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, d_real_array);
       current_statement__ = 308;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, d_vector);
       current_statement__ = 309;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, d_row_vector);
       current_statement__ = 310;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, p_real);
       current_statement__ = 311;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, p_real_array);
       current_statement__ = 312;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, p_vector);
       current_statement__ = 313;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 d_row_vector, p_row_vector);
       current_statement__ = 314;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, d_int);
       current_statement__ = 315;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, d_real);
       current_statement__ = 316;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, d_real_array);
       current_statement__ = 317;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, d_vector);
       current_statement__ = 318;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, d_row_vector);
       current_statement__ = 319;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, p_real);
       current_statement__ = 320;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, p_real_array);
       current_statement__ = 321;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, p_vector);
       current_statement__ = 322;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real, p_row_vector);
       current_statement__ = 323;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, d_int);
       current_statement__ = 324;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, d_real);
       current_statement__ = 325;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, d_real_array);
       current_statement__ = 326;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, d_vector);
       current_statement__ = 327;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, d_row_vector);
       current_statement__ = 328;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, p_real);
       current_statement__ = 329;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, p_real_array);
       current_statement__ = 330;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, p_vector);
       current_statement__ = 331;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_real_array, p_row_vector);
       current_statement__ = 332;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, d_int);
       current_statement__ = 333;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, d_real);
       current_statement__ = 334;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, d_real_array);
       current_statement__ = 335;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, d_vector);
       current_statement__ = 336;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, d_row_vector);
       current_statement__ = 337;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, p_real);
       current_statement__ = 338;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, p_real_array);
       current_statement__ = 339;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, p_vector);
       current_statement__ = 340;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_vector, p_row_vector);
       current_statement__ = 341;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, d_int);
       current_statement__ = 342;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, d_real);
       current_statement__ = 343;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, d_real_array);
       current_statement__ = 344;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, d_vector);
       current_statement__ = 345;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, d_row_vector);
       current_statement__ = 346;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, p_real);
       current_statement__ = 347;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, p_real_array);
       current_statement__ = 348;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, p_vector);
       current_statement__ = 349;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_vector,
+                                 p_row_vector, p_row_vector);
       current_statement__ = 350;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, d_int);
       current_statement__ = 351;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, d_real);
       current_statement__ = 352;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, d_real_array);
       current_statement__ = 353;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, d_vector);
       current_statement__ = 354;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, d_row_vector);
       current_statement__ = 355;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, p_real);
       current_statement__ = 356;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, p_real_array);
       current_statement__ = 357;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, p_vector);
       current_statement__ = 358;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_int, p_row_vector);
       current_statement__ = 359;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, d_int);
       current_statement__ = 360;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, d_real);
       current_statement__ = 361;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, d_real_array);
       current_statement__ = 362;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, d_vector);
       current_statement__ = 363;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, d_row_vector);
       current_statement__ = 364;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, p_real);
       current_statement__ = 365;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, p_real_array);
       current_statement__ = 366;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, p_vector);
       current_statement__ = 367;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real, p_row_vector);
       current_statement__ = 368;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, d_int);
       current_statement__ = 369;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, d_real);
       current_statement__ = 370;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, d_real_array);
       current_statement__ = 371;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, d_vector);
       current_statement__ = 372;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, d_row_vector);
       current_statement__ = 373;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, p_real);
       current_statement__ = 374;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, p_real_array);
       current_statement__ = 375;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, p_vector);
       current_statement__ = 376;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_real_array, p_row_vector);
       current_statement__ = 377;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, d_int);
       current_statement__ = 378;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, d_real);
       current_statement__ = 379;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, d_real_array);
       current_statement__ = 380;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, d_vector);
       current_statement__ = 381;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, d_row_vector);
       current_statement__ = 382;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, p_real);
       current_statement__ = 383;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, p_real_array);
       current_statement__ = 384;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, p_vector);
       current_statement__ = 385;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_vector, p_row_vector);
       current_statement__ = 386;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, d_int);
       current_statement__ = 387;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, d_real);
       current_statement__ = 388;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, d_real_array);
       current_statement__ = 389;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, d_vector);
       current_statement__ = 390;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, d_row_vector);
       current_statement__ = 391;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, p_real);
       current_statement__ = 392;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, p_real_array);
       current_statement__ = 393;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, p_vector);
       current_statement__ = 394;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 d_row_vector, p_row_vector);
       current_statement__ = 395;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, d_int);
       current_statement__ = 396;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, d_real);
       current_statement__ = 397;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, d_real_array);
       current_statement__ = 398;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, d_vector);
       current_statement__ = 399;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, d_row_vector);
       current_statement__ = 400;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, p_real);
       current_statement__ = 401;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, p_real_array);
       current_statement__ = 402;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, p_vector);
       current_statement__ = 403;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real, p_row_vector);
       current_statement__ = 404;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, d_int);
       current_statement__ = 405;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, d_real);
       current_statement__ = 406;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, d_real_array);
       current_statement__ = 407;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, d_vector);
       current_statement__ = 408;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, d_row_vector);
       current_statement__ = 409;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, p_real);
       current_statement__ = 410;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, p_real_array);
       current_statement__ = 411;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, p_vector);
       current_statement__ = 412;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_real_array, p_row_vector);
       current_statement__ = 413;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, d_int);
       current_statement__ = 414;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, d_real);
       current_statement__ = 415;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, d_real_array);
       current_statement__ = 416;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, d_vector);
       current_statement__ = 417;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, d_row_vector);
       current_statement__ = 418;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, p_real);
       current_statement__ = 419;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, p_real_array);
       current_statement__ = 420;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, p_vector);
       current_statement__ = 421;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_vector, p_row_vector);
       current_statement__ = 422;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, d_int);
       current_statement__ = 423;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, d_real);
       current_statement__ = 424;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, d_real_array);
       current_statement__ = 425;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, d_vector);
       current_statement__ = 426;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, d_row_vector);
       current_statement__ = 427;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, p_real);
       current_statement__ = 428;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, p_real_array);
       current_statement__ = 429;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, p_vector);
       current_statement__ = 430;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(d_row_vector,
+                                 p_row_vector, p_row_vector);
       current_statement__ = 431;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
                                  d_int);
@@ -8730,25 +7151,25 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 433;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 434;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 435;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 436;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
                                  p_real);
       current_statement__ = 437;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 438;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 439;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 440;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
                                  d_int);
@@ -8757,115 +7178,106 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 442;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 443;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 444;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 445;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
                                  p_real);
       current_statement__ = 446;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 447;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 448;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 449;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, d_int);
+                                 d_real_array, d_int);
       current_statement__ = 450;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, d_real);
+                                 d_real_array, d_real);
       current_statement__ = 451;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, d_real_array_opencl__);
+                                 d_real_array, d_real_array);
       current_statement__ = 452;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, d_vector_opencl__);
+                                 d_real_array, d_vector);
       current_statement__ = 453;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+                                 d_real_array, d_row_vector);
       current_statement__ = 454;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__, p_real);
+                                 d_real_array, p_real);
       current_statement__ = 455;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_real_array, p_real_array);
       current_statement__ = 456;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_real_array, p_vector);
       current_statement__ = 457;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_real_array, p_row_vector);
       current_statement__ = 458;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, d_int);
+                                 d_vector, d_int);
       current_statement__ = 459;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, d_real);
+                                 d_vector, d_real);
       current_statement__ = 460;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, d_real_array_opencl__);
+                                 d_vector, d_real_array);
       current_statement__ = 461;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, d_vector_opencl__);
+                                 d_vector, d_vector);
       current_statement__ = 462;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, d_row_vector_opencl__);
+                                 d_vector, d_row_vector);
       current_statement__ = 463;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__, p_real);
+                                 d_vector, p_real);
       current_statement__ = 464;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_vector, p_real_array);
       current_statement__ = 465;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_vector, p_vector);
       current_statement__ = 466;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_vector, p_row_vector);
       current_statement__ = 467;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, d_int);
+                                 d_row_vector, d_int);
       current_statement__ = 468;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, d_real);
+                                 d_row_vector, d_real);
       current_statement__ = 469;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+                                 d_row_vector, d_real_array);
       current_statement__ = 470;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, d_vector_opencl__);
+                                 d_row_vector, d_vector);
       current_statement__ = 471;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+                                 d_row_vector, d_row_vector);
       current_statement__ = 472;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__, p_real);
+                                 d_row_vector, p_real);
       current_statement__ = 473;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 d_row_vector, p_real_array);
       current_statement__ = 474;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 d_row_vector, p_vector);
       current_statement__ = 475;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 d_row_vector, p_row_vector);
       current_statement__ = 476;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
                                  d_int);
@@ -8874,1213 +7286,835 @@ class distributions_model final : public model_base_crtp<distributions_model> {
                                  d_real);
       current_statement__ = 478;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 d_real_array_opencl__);
+                                 d_real_array);
       current_statement__ = 479;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 d_vector_opencl__);
+                                 d_vector);
       current_statement__ = 480;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 d_row_vector_opencl__);
+                                 d_row_vector);
       current_statement__ = 481;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
                                  p_real);
       current_statement__ = 482;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array);
       current_statement__ = 483;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector);
       current_statement__ = 484;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real, p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector);
       current_statement__ = 485;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+                                 p_real_array, d_int);
       current_statement__ = 486;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+                                 p_real_array, d_real);
       current_statement__ = 487;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+                                 p_real_array, d_real_array);
       current_statement__ = 488;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+                                 p_real_array, d_vector);
       current_statement__ = 489;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+                                 p_real_array, d_row_vector);
       current_statement__ = 490;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+                                 p_real_array, p_real);
       current_statement__ = 491;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_real_array, p_real_array);
       current_statement__ = 492;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_real_array, p_vector);
       current_statement__ = 493;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_real_array, p_row_vector);
       current_statement__ = 494;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+                                 p_vector, d_int);
       current_statement__ = 495;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+                                 p_vector, d_real);
       current_statement__ = 496;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+                                 p_vector, d_real_array);
       current_statement__ = 497;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+                                 p_vector, d_vector);
       current_statement__ = 498;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+                                 p_vector, d_row_vector);
       current_statement__ = 499;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+                                 p_vector, p_real);
       current_statement__ = 500;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_vector, p_real_array);
       current_statement__ = 501;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_vector, p_vector);
       current_statement__ = 502;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_vector, p_row_vector);
       current_statement__ = 503;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+                                 p_row_vector, d_int);
       current_statement__ = 504;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+                                 p_row_vector, d_real);
       current_statement__ = 505;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+                                 p_row_vector, d_real_array);
       current_statement__ = 506;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+                                 p_row_vector, d_vector);
       current_statement__ = 507;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+                                 p_row_vector, d_row_vector);
       current_statement__ = 508;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+                                 p_row_vector, p_real);
       current_statement__ = 509;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+                                 p_row_vector, p_real_array);
       current_statement__ = 510;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+                                 p_row_vector, p_vector);
       current_statement__ = 511;
       transformed_param_real = stan::math::normal_lpdf<false>(p_real,
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+                                 p_row_vector, p_row_vector);
       current_statement__ = 512;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_int, d_int);
       current_statement__ = 513;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_int, d_real);
       current_statement__ = 514;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int, d_real_array);
       current_statement__ = 515;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int, d_vector);
       current_statement__ = 516;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int, d_row_vector);
       current_statement__ = 517;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_int, p_real);
       current_statement__ = 518;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int, p_real_array);
       current_statement__ = 519;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int, p_vector);
       current_statement__ = 520;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_int, p_row_vector);
       current_statement__ = 521;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_real, d_int);
       current_statement__ = 522;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_real, d_real);
       current_statement__ = 523;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real, d_real_array);
       current_statement__ = 524;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real, d_vector);
       current_statement__ = 525;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real, d_row_vector);
       current_statement__ = 526;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  d_real, p_real);
       current_statement__ = 527;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real, p_real_array);
       current_statement__ = 528;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real, p_vector);
       current_statement__ = 529;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real, p_row_vector);
       current_statement__ = 530;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, d_int);
       current_statement__ = 531;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, d_real);
       current_statement__ = 532;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, d_real_array);
       current_statement__ = 533;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, d_vector);
       current_statement__ = 534;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, d_row_vector);
       current_statement__ = 535;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, p_real);
       current_statement__ = 536;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, p_real_array);
       current_statement__ = 537;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, p_vector);
       current_statement__ = 538;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_real_array, p_row_vector);
       current_statement__ = 539;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, d_int);
       current_statement__ = 540;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, d_real);
       current_statement__ = 541;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, d_real_array);
       current_statement__ = 542;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, d_vector);
       current_statement__ = 543;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, d_row_vector);
       current_statement__ = 544;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, p_real);
       current_statement__ = 545;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, p_real_array);
       current_statement__ = 546;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, p_vector);
       current_statement__ = 547;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_vector, p_row_vector);
       current_statement__ = 548;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, d_int);
       current_statement__ = 549;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, d_real);
       current_statement__ = 550;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, d_real_array);
       current_statement__ = 551;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, d_vector);
       current_statement__ = 552;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, d_row_vector);
       current_statement__ = 553;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, p_real);
       current_statement__ = 554;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, p_real_array);
       current_statement__ = 555;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, p_vector);
       current_statement__ = 556;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 d_row_vector, p_row_vector);
       current_statement__ = 557;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  p_real, d_int);
       current_statement__ = 558;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  p_real, d_real);
       current_statement__ = 559;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, d_real_array);
       current_statement__ = 560;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, d_vector);
       current_statement__ = 561;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, d_row_vector);
       current_statement__ = 562;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
                                  p_real, p_real);
       current_statement__ = 563;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, p_real_array);
       current_statement__ = 564;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, p_vector);
       current_statement__ = 565;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real, p_row_vector);
       current_statement__ = 566;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_int);
       current_statement__ = 567;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_real);
       current_statement__ = 568;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_real_array);
       current_statement__ = 569;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_vector);
       current_statement__ = 570;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, d_row_vector);
       current_statement__ = 571;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, p_real);
       current_statement__ = 572;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, p_real_array);
       current_statement__ = 573;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, p_vector);
       current_statement__ = 574;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_real_array, p_row_vector);
       current_statement__ = 575;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_int);
       current_statement__ = 576;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_real);
       current_statement__ = 577;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_real_array);
       current_statement__ = 578;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_vector);
       current_statement__ = 579;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, d_row_vector);
       current_statement__ = 580;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, p_real);
       current_statement__ = 581;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, p_real_array);
       current_statement__ = 582;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, p_vector);
       current_statement__ = 583;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_vector, p_row_vector);
       current_statement__ = 584;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_int);
       current_statement__ = 585;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_real);
       current_statement__ = 586;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_real_array);
       current_statement__ = 587;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_vector);
       current_statement__ = 588;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, d_row_vector);
       current_statement__ = 589;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, p_real);
       current_statement__ = 590;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, p_real_array);
       current_statement__ = 591;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, p_vector);
       current_statement__ = 592;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_real_array,
+                                 p_row_vector, p_row_vector);
       current_statement__ = 593;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, d_int);
       current_statement__ = 594;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, d_real);
       current_statement__ = 595;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, d_real_array);
       current_statement__ = 596;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, d_vector);
       current_statement__ = 597;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, d_row_vector);
       current_statement__ = 598;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, p_real);
       current_statement__ = 599;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, p_real_array);
       current_statement__ = 600;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, p_vector);
       current_statement__ = 601;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_int, p_row_vector);
       current_statement__ = 602;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, d_int);
       current_statement__ = 603;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, d_real);
       current_statement__ = 604;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, d_real_array);
       current_statement__ = 605;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, d_vector);
       current_statement__ = 606;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, d_row_vector);
       current_statement__ = 607;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, p_real);
       current_statement__ = 608;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, p_real_array);
       current_statement__ = 609;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, p_vector);
       current_statement__ = 610;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real, p_row_vector);
       current_statement__ = 611;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, d_int);
       current_statement__ = 612;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, d_real);
       current_statement__ = 613;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, d_real_array);
       current_statement__ = 614;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, d_vector);
       current_statement__ = 615;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, d_row_vector);
       current_statement__ = 616;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, p_real);
       current_statement__ = 617;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, p_real_array);
       current_statement__ = 618;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, p_vector);
       current_statement__ = 619;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_real_array, p_row_vector);
       current_statement__ = 620;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, d_int);
       current_statement__ = 621;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, d_real);
       current_statement__ = 622;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, d_real_array);
       current_statement__ = 623;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, d_vector);
       current_statement__ = 624;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, d_row_vector);
       current_statement__ = 625;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, p_real);
       current_statement__ = 626;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, p_real_array);
       current_statement__ = 627;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, p_vector);
       current_statement__ = 628;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_vector, p_row_vector);
       current_statement__ = 629;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, d_int);
       current_statement__ = 630;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, d_real);
       current_statement__ = 631;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, d_real_array);
       current_statement__ = 632;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, d_vector);
       current_statement__ = 633;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, d_row_vector);
       current_statement__ = 634;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, p_real);
       current_statement__ = 635;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, p_real_array);
       current_statement__ = 636;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, p_vector);
       current_statement__ = 637;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 d_row_vector, p_row_vector);
       current_statement__ = 638;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_int);
       current_statement__ = 639;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_real);
       current_statement__ = 640;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_real_array);
       current_statement__ = 641;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_vector);
       current_statement__ = 642;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, d_row_vector);
       current_statement__ = 643;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, p_real);
       current_statement__ = 644;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, p_real_array);
       current_statement__ = 645;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, p_vector);
       current_statement__ = 646;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector), p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real, p_row_vector);
       current_statement__ = 647;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_int);
       current_statement__ = 648;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_real);
       current_statement__ = 649;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_real_array);
       current_statement__ = 650;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_vector);
       current_statement__ = 651;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, d_row_vector);
       current_statement__ = 652;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, p_real);
       current_statement__ = 653;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, p_real_array);
       current_statement__ = 654;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, p_vector);
       current_statement__ = 655;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_real_array, p_row_vector);
       current_statement__ = 656;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_int);
       current_statement__ = 657;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_real);
       current_statement__ = 658;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_real_array);
       current_statement__ = 659;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_vector);
       current_statement__ = 660;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, d_row_vector);
       current_statement__ = 661;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, p_real);
       current_statement__ = 662;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, p_real_array);
       current_statement__ = 663;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, p_vector);
       current_statement__ = 664;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_vector, p_row_vector);
       current_statement__ = 665;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_int);
       current_statement__ = 666;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_real);
       current_statement__ = 667;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_real_array);
       current_statement__ = 668;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_vector);
       current_statement__ = 669;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, d_row_vector);
       current_statement__ = 670;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, p_real);
       current_statement__ = 671;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, p_real_array);
       current_statement__ = 672;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, p_vector);
       current_statement__ = 673;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_vector,
+                                 p_row_vector, p_row_vector);
       current_statement__ = 674;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_int, d_int);
       current_statement__ = 675;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_int, d_real);
       current_statement__ = 676;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int, d_real_array);
       current_statement__ = 677;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int, d_vector);
       current_statement__ = 678;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int, d_row_vector);
       current_statement__ = 679;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_int, p_real);
       current_statement__ = 680;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int, p_real_array);
       current_statement__ = 681;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int, p_vector);
       current_statement__ = 682;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_int, p_row_vector);
       current_statement__ = 683;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_real, d_int);
       current_statement__ = 684;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_real, d_real);
       current_statement__ = 685;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real, d_real_array);
       current_statement__ = 686;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real, d_vector);
       current_statement__ = 687;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real, d_row_vector);
       current_statement__ = 688;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  d_real, p_real);
       current_statement__ = 689;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real, p_real_array);
       current_statement__ = 690;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real, p_vector);
       current_statement__ = 691;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real, p_row_vector);
       current_statement__ = 692;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, d_int);
       current_statement__ = 693;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, d_real);
       current_statement__ = 694;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, d_real_array);
       current_statement__ = 695;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, d_vector);
       current_statement__ = 696;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, d_row_vector);
       current_statement__ = 697;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, p_real);
       current_statement__ = 698;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, p_real_array);
       current_statement__ = 699;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, p_vector);
       current_statement__ = 700;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_real_array, p_row_vector);
       current_statement__ = 701;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, d_int);
       current_statement__ = 702;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, d_real);
       current_statement__ = 703;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, d_real_array);
       current_statement__ = 704;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, d_vector);
       current_statement__ = 705;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, d_row_vector);
       current_statement__ = 706;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, p_real);
       current_statement__ = 707;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, p_real_array);
       current_statement__ = 708;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, p_vector);
       current_statement__ = 709;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_vector, p_row_vector);
       current_statement__ = 710;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, d_int);
       current_statement__ = 711;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, d_real);
       current_statement__ = 712;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, d_real_array);
       current_statement__ = 713;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, d_vector);
       current_statement__ = 714;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, d_row_vector);
       current_statement__ = 715;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__, p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, p_real);
       current_statement__ = 716;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, p_real_array);
       current_statement__ = 717;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, p_vector);
       current_statement__ = 718;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 d_row_vector, p_row_vector);
       current_statement__ = 719;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  p_real, d_int);
       current_statement__ = 720;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  p_real, d_real);
       current_statement__ = 721;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real, d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, d_real_array);
       current_statement__ = 722;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real, d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, d_vector);
       current_statement__ = 723;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real, d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, d_row_vector);
       current_statement__ = 724;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
                                  p_real, p_real);
       current_statement__ = 725;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real,
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, p_real_array);
       current_statement__ = 726;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real, stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, p_vector);
       current_statement__ = 727;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real,
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real, p_row_vector);
       current_statement__ = 728;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_int);
       current_statement__ = 729;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_real);
       current_statement__ = 730;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_real_array);
       current_statement__ = 731;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_vector);
       current_statement__ = 732;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, d_row_vector);
       current_statement__ = 733;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, p_real);
       current_statement__ = 734;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, p_real_array);
       current_statement__ = 735;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, p_vector);
       current_statement__ = 736;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_real_array, p_row_vector);
       current_statement__ = 737;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector), d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_int);
       current_statement__ = 738;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector), d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_real);
       current_statement__ = 739;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_real_array);
       current_statement__ = 740;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_vector);
       current_statement__ = 741;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, d_row_vector);
       current_statement__ = 742;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector), p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, p_real);
       current_statement__ = 743;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, p_real_array);
       current_statement__ = 744;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, p_vector);
       current_statement__ = 745;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_vector, p_row_vector);
       current_statement__ = 746;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_int);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_int);
       current_statement__ = 747;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_real);
       current_statement__ = 748;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_real_array_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_real_array);
       current_statement__ = 749;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_vector);
       current_statement__ = 750;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 d_row_vector_opencl__);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, d_row_vector);
       current_statement__ = 751;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 p_real);
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, p_real);
       current_statement__ = 752;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_real_array));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, p_real_array);
       current_statement__ = 753;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, p_vector);
       current_statement__ = 754;
-      transformed_param_real = stan::math::normal_lpdf<false>(
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector),
-                                 stan::math::to_matrix_cl(p_row_vector));
+      transformed_param_real = stan::math::normal_lpdf<false>(p_row_vector,
+                                 p_row_vector, p_row_vector);
       if (emit_transformed_parameters__) {
         out__.write(transformed_param_real);
       }
@@ -10491,7 +8525,9 @@ class restricted_model final : public model_base_crtp<restricted_model> {
   std::vector<double> d_real_array;
   Eigen::Matrix<double,-1,1> d_vector_data__;
   Eigen::Matrix<double,1,-1> d_row_vector_data__;
-  matrix_cl<double> d_vector_opencl__;
+  stan::math::matrix_cl<int> d_int_array_opencl__;
+  stan::math::matrix_cl<double> d_real_opencl__;
+  stan::math::matrix_cl<double> d_vector_opencl__;
   Eigen::Map<Eigen::Matrix<double,-1,1>> d_vector{nullptr, 0};
   Eigen::Map<Eigen::Matrix<double,1,-1>> d_row_vector{nullptr, 0};
  public:
@@ -10595,6 +8631,18 @@ class restricted_model final : public model_base_crtp<restricted_model> {
       stan::math::validate_non_negative_index("p_vector", "d_int", d_int);
       current_statement__ = 39;
       stan::math::validate_non_negative_index("p_row_vector", "d_int", d_int);
+      current_statement__ = 27;
+      d_int_array_opencl__ = std::vector<int>(d_int,
+                               std::numeric_limits<int>::min());
+      current_statement__ = 27;
+      d_int_array_opencl__ = stan::math::to_matrix_cl(d_int_array);
+      current_statement__ = 28;
+      d_real_opencl__ = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 28;
+      d_real_opencl__ = stan::math::to_matrix_cl(d_real);
+      current_statement__ = 32;
+      d_vector_opencl__ = stan::math::to_matrix_cl(d_vector);
+      current_statement__ = 32;
       d_vector_opencl__ = stan::math::to_matrix_cl(d_vector);
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
@@ -10684,31 +8732,29 @@ class restricted_model final : public model_base_crtp<restricted_model> {
       transformed_param_real = stan::math::uniform_lpdf<false>(p_vector,
                                  p_real, p_real);
       current_statement__ = 17;
-      transformed_param_real = stan::math::exponential_lpdf<false>(
-                                 d_vector_opencl__, d_real);
+      transformed_param_real = stan::math::exponential_lpdf<false>(d_vector,
+                                 d_real);
       current_statement__ = 18;
-      transformed_param_real = stan::math::exponential_lpdf<false>(
-                                 d_vector_opencl__, p_real);
+      transformed_param_real = stan::math::exponential_lpdf<false>(d_vector,
+                                 p_real);
       current_statement__ = 19;
-      transformed_param_real = stan::math::std_normal_lpdf<false>(
-                                 d_vector_opencl__);
+      transformed_param_real = stan::math::std_normal_lpdf<false>(d_vector);
       current_statement__ = 20;
-      transformed_param_real = stan::math::uniform_lpdf<false>(
-                                 d_vector_opencl__, d_real, d_real);
+      transformed_param_real = stan::math::uniform_lpdf<false>(d_vector,
+                                 d_real, d_real);
       current_statement__ = 21;
-      transformed_param_real = stan::math::uniform_lpdf<false>(
-                                 d_vector_opencl__, d_real, p_real);
+      transformed_param_real = stan::math::uniform_lpdf<false>(d_vector,
+                                 d_real, p_real);
       current_statement__ = 22;
-      transformed_param_real = stan::math::uniform_lpdf<false>(
-                                 d_vector_opencl__, p_real, d_real);
+      transformed_param_real = stan::math::uniform_lpdf<false>(d_vector,
+                                 p_real, d_real);
       current_statement__ = 23;
-      transformed_param_real = stan::math::uniform_lpdf<false>(
-                                 d_vector_opencl__, p_real, p_real);
+      transformed_param_real = stan::math::uniform_lpdf<false>(d_vector,
+                                 p_real, p_real);
       {
         current_statement__ = 24;
         lp_accum__.add(stan::math::normal_lpdf<propto__>(y_p, 0, 1));
       }
-      d_vector_opencl__.wait_for_read_write_events();
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
     }
@@ -10737,42 +8783,52 @@ class restricted_model final : public model_base_crtp<restricted_model> {
     // suppress unused var warning
     (void) function__;
     try {
-      local_scalar_t__ p_real = DUMMY_VAR__;
+      stan::math::matrix_cl<local_scalar_t__> p_real = DUMMY_VAR__;
       current_statement__ = 1;
-      p_real = in__.template read<local_scalar_t__>();
-      std::vector<local_scalar_t__> p_real_array =
-        std::vector<local_scalar_t__>(d_int, DUMMY_VAR__);
-      current_statement__ = 2;
-      p_real_array = in__.template read<std::vector<local_scalar_t__>>(d_int);
-      Eigen::Matrix<local_scalar_t__,-1,-1> p_matrix =
-        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(d_int, d_int,
+      p_real = in__.template read<stan::math::matrix_cl<local_scalar_t__>>();
+      std::vector<stan::math::matrix_cl<local_scalar_t__>> p_real_array =
+        std::vector<stan::math::matrix_cl<local_scalar_t__>>(d_int,
           DUMMY_VAR__);
+      current_statement__ = 2;
+      p_real_array = in__.template read<
+                       std::vector<stan::math::matrix_cl<local_scalar_t__>>>(d_int);
+      stan::math::var_value<stan::math::matrix_cl<double>> p_matrix =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,-1>::Constant(d_int,
+                                                               d_int,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
       current_statement__ = 3;
       p_matrix = in__.template read<
-                   Eigen::Matrix<local_scalar_t__,-1,-1>>(d_int, d_int);
-      Eigen::Matrix<local_scalar_t__,-1,1> p_vector =
-        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(d_int, DUMMY_VAR__);
+                   stan::math::var_value<stan::math::matrix_cl<double>>>(d_int,
+                   d_int);
+      stan::math::var_value<stan::math::matrix_cl<double>> p_vector =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,1>::Constant(d_int,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
       current_statement__ = 4;
       p_vector = in__.template read<
-                   Eigen::Matrix<local_scalar_t__,-1,1>>(d_int);
-      Eigen::Matrix<local_scalar_t__,1,-1> p_row_vector =
-        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(d_int, DUMMY_VAR__);
+                   stan::math::var_value<stan::math::matrix_cl<double>>>(d_int);
+      stan::math::var_value<stan::math::matrix_cl<double>> p_row_vector =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,1,-1>::Constant(d_int,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
       current_statement__ = 5;
       p_row_vector = in__.template read<
-                       Eigen::Matrix<local_scalar_t__,1,-1>>(d_int);
-      local_scalar_t__ y_p = DUMMY_VAR__;
+                       stan::math::var_value<stan::math::matrix_cl<double>>>(d_int);
+      stan::math::matrix_cl<local_scalar_t__> y_p = DUMMY_VAR__;
       current_statement__ = 6;
-      y_p = in__.template read<local_scalar_t__>();
-      local_scalar_t__ transformed_param_real = DUMMY_VAR__;
+      y_p = in__.template read<stan::math::matrix_cl<local_scalar_t__>>();
+      stan::math::matrix_cl<local_scalar_t__> transformed_param_real =
+        DUMMY_VAR__;
       current_statement__ = 8;
-      transformed_param_real = stan::math::bernoulli_lpmf<false>(d_int_array,
-                                 d_real);
+      transformed_param_real = stan::math::bernoulli_lpmf<false>(
+                                 d_int_array_opencl__, d_real_opencl__);
       current_statement__ = 9;
-      transformed_param_real = stan::math::bernoulli_lpmf<false>(d_int_array,
-                                 p_real);
+      transformed_param_real = stan::math::bernoulli_lpmf<false>(
+                                 d_int_array_opencl__, p_real);
       current_statement__ = 10;
       transformed_param_real = stan::math::exponential_lpdf<false>(p_vector,
-                                 d_real);
+                                 d_real_opencl__);
       current_statement__ = 11;
       transformed_param_real = stan::math::exponential_lpdf<false>(p_vector,
                                  p_real);
@@ -10780,19 +8836,19 @@ class restricted_model final : public model_base_crtp<restricted_model> {
       transformed_param_real = stan::math::std_normal_lpdf<false>(p_vector);
       current_statement__ = 13;
       transformed_param_real = stan::math::uniform_lpdf<false>(p_vector,
-                                 d_real, d_real);
+                                 d_real_opencl__, d_real_opencl__);
       current_statement__ = 14;
       transformed_param_real = stan::math::uniform_lpdf<false>(p_vector,
-                                 d_real, p_real);
+                                 d_real_opencl__, p_real);
       current_statement__ = 15;
       transformed_param_real = stan::math::uniform_lpdf<false>(p_vector,
-                                 p_real, d_real);
+                                 p_real, d_real_opencl__);
       current_statement__ = 16;
       transformed_param_real = stan::math::uniform_lpdf<false>(p_vector,
                                  p_real, p_real);
       current_statement__ = 17;
       transformed_param_real = stan::math::exponential_lpdf<false>(
-                                 d_vector_opencl__, d_real);
+                                 d_vector_opencl__, d_real_opencl__);
       current_statement__ = 18;
       transformed_param_real = stan::math::exponential_lpdf<false>(
                                  d_vector_opencl__, p_real);
@@ -10801,13 +8857,14 @@ class restricted_model final : public model_base_crtp<restricted_model> {
                                  d_vector_opencl__);
       current_statement__ = 20;
       transformed_param_real = stan::math::uniform_lpdf<false>(
-                                 d_vector_opencl__, d_real, d_real);
+                                 d_vector_opencl__, d_real_opencl__,
+                                 d_real_opencl__);
       current_statement__ = 21;
       transformed_param_real = stan::math::uniform_lpdf<false>(
-                                 d_vector_opencl__, d_real, p_real);
+                                 d_vector_opencl__, d_real_opencl__, p_real);
       current_statement__ = 22;
       transformed_param_real = stan::math::uniform_lpdf<false>(
-                                 d_vector_opencl__, p_real, d_real);
+                                 d_vector_opencl__, p_real, d_real_opencl__);
       current_statement__ = 23;
       transformed_param_real = stan::math::uniform_lpdf<false>(
                                  d_vector_opencl__, p_real, p_real);
@@ -10815,7 +8872,6 @@ class restricted_model final : public model_base_crtp<restricted_model> {
         current_statement__ = 24;
         lp_accum__.add(stan::math::normal_lpdf<propto__>(y_p, 0, 1));
       }
-      d_vector_opencl__.wait_for_read_write_events();
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
     }
@@ -10851,98 +8907,666 @@ class restricted_model final : public model_base_crtp<restricted_model> {
     // suppress unused var warning
     (void) jacobian__;
     static constexpr const char* function__ =
-      "restricted_model_namespace::write_array";
+      "restricted_model_namespace::write_array";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      double p_real = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 1;
+      p_real = in__.template read<local_scalar_t__>();
+      std::vector<double> p_real_array =
+        std::vector<double>(d_int, std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 2;
+      p_real_array = in__.template read<std::vector<local_scalar_t__>>(d_int);
+      Eigen::Matrix<double,-1,-1> p_matrix =
+        Eigen::Matrix<double,-1,-1>::Constant(d_int, d_int,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 3;
+      p_matrix = in__.template read<
+                   Eigen::Matrix<local_scalar_t__,-1,-1>>(d_int, d_int);
+      Eigen::Matrix<double,-1,1> p_vector =
+        Eigen::Matrix<double,-1,1>::Constant(d_int,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 4;
+      p_vector = in__.template read<
+                   Eigen::Matrix<local_scalar_t__,-1,1>>(d_int);
+      Eigen::Matrix<double,1,-1> p_row_vector =
+        Eigen::Matrix<double,1,-1>::Constant(d_int,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 5;
+      p_row_vector = in__.template read<
+                       Eigen::Matrix<local_scalar_t__,1,-1>>(d_int);
+      double y_p = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 6;
+      y_p = in__.template read<local_scalar_t__>();
+      double transformed_param_real =
+        std::numeric_limits<double>::quiet_NaN();
+      out__.write(p_real);
+      out__.write(p_real_array);
+      out__.write(p_matrix);
+      out__.write(p_vector);
+      out__.write(p_row_vector);
+      out__.write(y_p);
+      if (stan::math::logical_negation(
+            (stan::math::primitive_value(emit_transformed_parameters__) ||
+            stan::math::primitive_value(emit_generated_quantities__)))) {
+        return ;
+      }
+      current_statement__ = 8;
+      transformed_param_real = stan::math::bernoulli_lpmf<false>(d_int_array,
+                                 d_real);
+      current_statement__ = 9;
+      transformed_param_real = stan::math::bernoulli_lpmf<false>(d_int_array,
+                                 p_real);
+      current_statement__ = 10;
+      transformed_param_real = stan::math::exponential_lpdf<false>(p_vector,
+                                 d_real);
+      current_statement__ = 11;
+      transformed_param_real = stan::math::exponential_lpdf<false>(p_vector,
+                                 p_real);
+      current_statement__ = 12;
+      transformed_param_real = stan::math::std_normal_lpdf<false>(p_vector);
+      current_statement__ = 13;
+      transformed_param_real = stan::math::uniform_lpdf<false>(p_vector,
+                                 d_real, d_real);
+      current_statement__ = 14;
+      transformed_param_real = stan::math::uniform_lpdf<false>(p_vector,
+                                 d_real, p_real);
+      current_statement__ = 15;
+      transformed_param_real = stan::math::uniform_lpdf<false>(p_vector,
+                                 p_real, d_real);
+      current_statement__ = 16;
+      transformed_param_real = stan::math::uniform_lpdf<false>(p_vector,
+                                 p_real, p_real);
+      current_statement__ = 17;
+      transformed_param_real = stan::math::exponential_lpdf<false>(d_vector,
+                                 d_real);
+      current_statement__ = 18;
+      transformed_param_real = stan::math::exponential_lpdf<false>(d_vector,
+                                 p_real);
+      current_statement__ = 19;
+      transformed_param_real = stan::math::std_normal_lpdf<false>(d_vector);
+      current_statement__ = 20;
+      transformed_param_real = stan::math::uniform_lpdf<false>(d_vector,
+                                 d_real, d_real);
+      current_statement__ = 21;
+      transformed_param_real = stan::math::uniform_lpdf<false>(d_vector,
+                                 d_real, p_real);
+      current_statement__ = 22;
+      transformed_param_real = stan::math::uniform_lpdf<false>(d_vector,
+                                 p_real, d_real);
+      current_statement__ = 23;
+      transformed_param_real = stan::math::uniform_lpdf<false>(d_vector,
+                                 p_real, p_real);
+      if (emit_transformed_parameters__) {
+        out__.write(transformed_param_real);
+      }
+      if (stan::math::logical_negation(emit_generated_quantities__)) {
+        return ;
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, typename VecI,
+            stan::require_vector_t<VecVar>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr>
+  inline void
+  unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__,
+                         VecVar& vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      local_scalar_t__ p_real = DUMMY_VAR__;
+      current_statement__ = 1;
+      p_real = in__.read<local_scalar_t__>();
+      out__.write(p_real);
+      std::vector<local_scalar_t__> p_real_array =
+        std::vector<local_scalar_t__>(d_int, DUMMY_VAR__);
+      current_statement__ = 2;
+      stan::model::assign(p_real_array,
+        in__.read<std::vector<local_scalar_t__>>(d_int),
+        "assigning variable p_real_array");
+      out__.write(p_real_array);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_matrix =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(d_int, d_int,
+          DUMMY_VAR__);
+      current_statement__ = 3;
+      stan::model::assign(p_matrix,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(d_int, d_int),
+        "assigning variable p_matrix");
+      out__.write(p_matrix);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_vector =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(d_int, DUMMY_VAR__);
+      current_statement__ = 4;
+      stan::model::assign(p_vector,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(d_int),
+        "assigning variable p_vector");
+      out__.write(p_vector);
+      Eigen::Matrix<local_scalar_t__,1,-1> p_row_vector =
+        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(d_int, DUMMY_VAR__);
+      current_statement__ = 5;
+      stan::model::assign(p_row_vector,
+        in__.read<Eigen::Matrix<local_scalar_t__,1,-1>>(d_int),
+        "assigning variable p_row_vector");
+      out__.write(p_row_vector);
+      local_scalar_t__ y_p = DUMMY_VAR__;
+      current_statement__ = 6;
+      y_p = in__.read<local_scalar_t__>();
+      out__.write(y_p);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, stan::require_vector_t<VecVar>* = nullptr>
+  inline void
+  transform_inits_impl(const stan::io::var_context& context__, VecVar&
+                       vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 1;
+      context__.validate_dims("parameter initialization", "p_real", "double",
+        std::vector<size_t>{});
+      current_statement__ = 2;
+      context__.validate_dims("parameter initialization", "p_real_array",
+        "double", std::vector<size_t>{static_cast<size_t>(d_int)});
+      current_statement__ = 3;
+      context__.validate_dims("parameter initialization", "p_matrix",
+        "double",
+        std::vector<size_t>{static_cast<size_t>(d_int),
+          static_cast<size_t>(d_int)});
+      current_statement__ = 4;
+      context__.validate_dims("parameter initialization", "p_vector",
+        "double", std::vector<size_t>{static_cast<size_t>(d_int)});
+      current_statement__ = 5;
+      context__.validate_dims("parameter initialization", "p_row_vector",
+        "double", std::vector<size_t>{static_cast<size_t>(d_int)});
+      current_statement__ = 6;
+      context__.validate_dims("parameter initialization", "y_p", "double",
+        std::vector<size_t>{});
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      local_scalar_t__ p_real = DUMMY_VAR__;
+      current_statement__ = 1;
+      p_real = context__.vals_r("p_real")[(1 - 1)];
+      out__.write(p_real);
+      std::vector<local_scalar_t__> p_real_array =
+        std::vector<local_scalar_t__>(d_int, DUMMY_VAR__);
+      current_statement__ = 2;
+      p_real_array = context__.vals_r("p_real_array");
+      out__.write(p_real_array);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_matrix =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(d_int, d_int,
+          DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_matrix_flat__;
+        current_statement__ = 3;
+        p_matrix_flat__ = context__.vals_r("p_matrix");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= d_int; ++sym2__) {
+            stan::model::assign(p_matrix, p_matrix_flat__[(pos__ - 1)],
+              "assigning variable p_matrix", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(p_matrix);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_vector =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(d_int, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_vector_flat__;
+        current_statement__ = 4;
+        p_vector_flat__ = context__.vals_r("p_vector");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
+          stan::model::assign(p_vector, p_vector_flat__[(pos__ - 1)],
+            "assigning variable p_vector", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(p_vector);
+      Eigen::Matrix<local_scalar_t__,1,-1> p_row_vector =
+        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(d_int, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_row_vector_flat__;
+        current_statement__ = 5;
+        p_row_vector_flat__ = context__.vals_r("p_row_vector");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
+          stan::model::assign(p_row_vector, p_row_vector_flat__[(pos__ - 1)],
+            "assigning variable p_row_vector", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(p_row_vector);
+      local_scalar_t__ y_p = DUMMY_VAR__;
+      current_statement__ = 6;
+      y_p = context__.vals_r("y_p")[(1 - 1)];
+      out__.write(y_p);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  inline void
+  get_param_names(std::vector<std::string>& names__, const bool
+                  emit_transformed_parameters__ = true, const bool
+                  emit_generated_quantities__ = true) const {
+    names__ = std::vector<std::string>{"p_real", "p_real_array", "p_matrix",
+                "p_vector", "p_row_vector", "y_p"};
+    if (emit_transformed_parameters__) {
+      std::vector<std::string> temp{"transformed_param_real"};
+      names__.reserve(names__.size() + temp.size());
+      names__.insert(names__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  get_dims(std::vector<std::vector<size_t>>& dimss__, const bool
+           emit_transformed_parameters__ = true, const bool
+           emit_generated_quantities__ = true) const {
+    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{},
+                std::vector<size_t>{static_cast<size_t>(d_int)},
+                std::vector<size_t>{static_cast<size_t>(d_int),
+                  static_cast<size_t>(d_int)},
+                std::vector<size_t>{static_cast<size_t>(d_int)},
+                std::vector<size_t>{static_cast<size_t>(d_int)},
+                std::vector<size_t>{}};
+    if (emit_transformed_parameters__) {
+      std::vector<std::vector<size_t>> temp{std::vector<size_t>{}};
+      dimss__.reserve(dimss__.size() + temp.size());
+      dimss__.insert(dimss__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  constrained_param_names(std::vector<std::string>& param_names__, bool
+                          emit_transformed_parameters__ = true, bool
+                          emit_generated_quantities__ = true) const final {
+    param_names__.emplace_back(std::string() + "p_real");
+    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_real_array" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= d_int; ++sym2__) {
+        param_names__.emplace_back(std::string() + "p_matrix" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_vector" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_row_vector" + '.' +
+        std::to_string(sym1__));
+    }
+    param_names__.emplace_back(std::string() + "y_p");
+    if (emit_transformed_parameters__) {
+      param_names__.emplace_back(std::string() + "transformed_param_real");
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  unconstrained_param_names(std::vector<std::string>& param_names__, bool
+                            emit_transformed_parameters__ = true, bool
+                            emit_generated_quantities__ = true) const final {
+    param_names__.emplace_back(std::string() + "p_real");
+    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_real_array" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= d_int; ++sym2__) {
+        param_names__.emplace_back(std::string() + "p_matrix" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_vector" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_row_vector" + '.' +
+        std::to_string(sym1__));
+    }
+    param_names__.emplace_back(std::string() + "y_p");
+    if (emit_transformed_parameters__) {
+      param_names__.emplace_back(std::string() + "transformed_param_real");
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline std::string get_constrained_sizedtypes() const {
+    return std::string("[{\"name\":\"p_real\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"p_real_array\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(d_int) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"p_matrix\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(d_int) + ",\"cols\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"p_vector\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"p_row_vector\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"y_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"transformed_param_real\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]");
+  }
+  inline std::string get_unconstrained_sizedtypes() const {
+    return std::string("[{\"name\":\"p_real\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"p_real_array\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(d_int) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"p_matrix\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(d_int) + ",\"cols\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"p_vector\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"p_row_vector\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"y_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"transformed_param_real\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]");
+  }
+  // Begin method overload boilerplate
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, Eigen::Matrix<double,-1,1>& params_r,
+              Eigen::Matrix<double,-1,1>& vars, const bool
+              emit_transformed_parameters = true, const bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (((((1 + d_int) + (d_int * d_int)) + d_int) +
+      d_int) + 1);
+    const size_t num_transformed = emit_transformed_parameters * (1);
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    std::vector<int> params_i;
+    vars = Eigen::Matrix<double,-1,1>::Constant(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, std::vector<double>& params_r, std::vector<int>&
+              params_i, std::vector<double>& vars, bool
+              emit_transformed_parameters = true, bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (((((1 + d_int) + (d_int * d_int)) + d_int) +
+      d_int) + 1);
+    const size_t num_transformed = emit_transformed_parameters * (1);
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    vars = std::vector<double>(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(Eigen::Matrix<T_,-1,1>& params_r, std::ostream* pstream = nullptr) const {
+    Eigen::Matrix<int,-1,1> params_i;
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(std::vector<T_>& params_r, std::vector<int>& params_i,
+           std::ostream* pstream = nullptr) const {
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context,
+                  Eigen::Matrix<double,-1,1>& params_r, std::ostream*
+                  pstream = nullptr) const final {
+    std::vector<double> params_r_vec(params_r.size());
+    std::vector<int> params_i;
+    transform_inits(context, params_i, params_r_vec, pstream);
+    params_r = Eigen::Map<Eigen::Matrix<double,-1,1>>(params_r_vec.data(),
+                 params_r_vec.size());
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context, std::vector<int>&
+                  params_i, std::vector<double>& vars, std::ostream*
+                  pstream__ = nullptr) const {
+    vars.resize(num_params_r__);
+    transform_inits_impl(context, vars, pstream__);
+  }
+  inline void
+  unconstrain_array(const std::vector<double>& params_constrained,
+                    std::vector<double>& params_unconstrained, std::ostream*
+                    pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = std::vector<double>(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+  inline void
+  unconstrain_array(const Eigen::Matrix<double,-1,1>& params_constrained,
+                    Eigen::Matrix<double,-1,1>& params_unconstrained,
+                    std::ostream* pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = Eigen::Matrix<double,-1,1>::Constant(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+};
+}
+using stan_model = restricted_model_namespace::restricted_model;
+#ifndef USING_R
+// Boilerplate
+stan::model::model_base&
+new_model(stan::io::var_context& data_context, unsigned int seed,
+          std::ostream* msg_stream) {
+  stan_model* m = new stan_model(data_context, seed, msg_stream);
+  return *m;
+}
+stan::math::profile_map& get_stan_profile_data() {
+  return restricted_model_namespace::profiles__;
+}
+#endif
+  $ ../../../../../../install/default/bin/stanc --print-cpp --use-opencl tiny.stan
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace tiny_model_namespace {
+using stan::model::model_base_crtp;
+using namespace stan::math;
+stan::math::profile_map profiles__;
+static constexpr std::array<const char*, 9> locations_array__ =
+  {" (found before start of program)",
+  " (in 'tiny.stan', line 6, column 2 to column 25)",
+  " (in 'tiny.stan', line 9, column 2 to column 30)",
+  " (in 'tiny.stan', line 10, column 2 to column 65)",
+  " (in 'tiny.stan', line 11, column 2 to column 71)",
+  " (in 'tiny.stan', line 2, column 2 to column 12)",
+  " (in 'tiny.stan', line 3, column 8 to column 13)",
+  " (in 'tiny.stan', line 3, column 2 to column 31)",
+  " (in 'tiny.stan', line 6, column 9 to column 14)"};
+class tiny_model final : public model_base_crtp<tiny_model> {
+ private:
+  int d_int;
+  std::vector<int> d_int_array;
+  stan::math::matrix_cl<int> d_int_opencl__;
+  stan::math::matrix_cl<int> d_int_array_opencl__;
+ public:
+  ~tiny_model() {}
+  tiny_model(stan::io::var_context& context__, unsigned int
+             random_seed__ = 0, std::ostream* pstream__ = nullptr)
+      : model_base_crtp(0) {
+    int current_statement__ = 0;
+    using local_scalar_t__ = double;
+    boost::ecuyer1988 base_rng__ =
+      stan::services::util::create_rng(random_seed__, 0);
+    // suppress unused var warning
+    (void) base_rng__;
+    static constexpr const char* function__ =
+      "tiny_model_namespace::tiny_model";
+    // suppress unused var warning
+    (void) function__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 5;
+      context__.validate_dims("data initialization", "d_int", "int",
+        std::vector<size_t>{});
+      d_int = std::numeric_limits<int>::min();
+      current_statement__ = 5;
+      d_int = context__.vals_i("d_int")[(1 - 1)];
+      current_statement__ = 6;
+      stan::math::validate_non_negative_index("d_int_array", "d_int", d_int);
+      current_statement__ = 7;
+      context__.validate_dims("data initialization", "d_int_array", "int",
+        std::vector<size_t>{static_cast<size_t>(d_int)});
+      d_int_array = std::vector<int>(d_int, std::numeric_limits<int>::min());
+      current_statement__ = 7;
+      d_int_array = context__.vals_i("d_int_array");
+      current_statement__ = 8;
+      stan::math::validate_non_negative_index("p_vector", "d_int", d_int);
+      current_statement__ = 5;
+      d_int_opencl__ = std::numeric_limits<int>::min();
+      current_statement__ = 5;
+      d_int_opencl__ = stan::math::to_matrix_cl(d_int);
+      current_statement__ = 7;
+      d_int_array_opencl__ = std::vector<int>(d_int,
+                               std::numeric_limits<int>::min());
+      current_statement__ = 7;
+      d_int_array_opencl__ = stan::math::to_matrix_cl(d_int_array);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    num_params_r__ = d_int;
+  }
+  inline std::string model_name() const final {
+    return "tiny_model";
+  }
+  inline std::vector<std::string> model_compile_info() const noexcept {
+    return std::vector<std::string>{"stanc_version = %%NAME%%3 %%VERSION%%",
+             "stancflags = --print-cpp --use-opencl"};
+  }
+  // Base log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_not_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "tiny_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,1> p_vector =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(d_int, DUMMY_VAR__);
+      current_statement__ = 1;
+      p_vector = in__.template read<
+                   Eigen::Matrix<local_scalar_t__,-1,1>>(d_int);
+      local_scalar_t__ transformed_param_real = DUMMY_VAR__;
+      current_statement__ = 3;
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
+                                 p_vector);
+      current_statement__ = 4;
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
+                                 d_int_array, p_vector);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  // Reverse mode autodiff log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "tiny_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      stan::math::var_value<stan::math::matrix_cl<double>> p_vector =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,1>::Constant(d_int,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
+      current_statement__ = 1;
+      p_vector = in__.template read<
+                   stan::math::var_value<stan::math::matrix_cl<double>>>(d_int);
+      stan::math::matrix_cl<local_scalar_t__> transformed_param_real =
+        DUMMY_VAR__;
+      current_statement__ = 3;
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
+                                 d_int_opencl__, p_vector);
+      current_statement__ = 4;
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
+                                 d_int_array_opencl__, p_vector);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  template <typename RNG, typename VecR, typename VecI, typename VecVar,
+            stan::require_vector_like_vt<std::is_floating_point,
+            VecR>* = nullptr, stan::require_vector_like_vt<std::is_integral,
+            VecI>* = nullptr, stan::require_vector_vt<std::is_floating_point,
+            VecVar>* = nullptr>
+  inline void
+  write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__,
+                   VecVar& vars__, const bool
+                   emit_transformed_parameters__ = true, const bool
+                   emit_generated_quantities__ = true, std::ostream*
+                   pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    static constexpr bool propto__ = true;
+    // suppress unused var warning
+    (void) propto__;
+    double lp__ = 0.0;
+    // suppress unused var warning
+    (void) lp__;
+    int current_statement__ = 0;
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    constexpr bool jacobian__ = false;
+    // suppress unused var warning
+    (void) jacobian__;
+    static constexpr const char* function__ =
+      "tiny_model_namespace::write_array";
     // suppress unused var warning
     (void) function__;
     try {
-      double p_real = std::numeric_limits<double>::quiet_NaN();
-      current_statement__ = 1;
-      p_real = in__.template read<local_scalar_t__>();
-      std::vector<double> p_real_array =
-        std::vector<double>(d_int, std::numeric_limits<double>::quiet_NaN());
-      current_statement__ = 2;
-      p_real_array = in__.template read<std::vector<local_scalar_t__>>(d_int);
-      Eigen::Matrix<double,-1,-1> p_matrix =
-        Eigen::Matrix<double,-1,-1>::Constant(d_int, d_int,
-          std::numeric_limits<double>::quiet_NaN());
-      current_statement__ = 3;
-      p_matrix = in__.template read<
-                   Eigen::Matrix<local_scalar_t__,-1,-1>>(d_int, d_int);
       Eigen::Matrix<double,-1,1> p_vector =
         Eigen::Matrix<double,-1,1>::Constant(d_int,
           std::numeric_limits<double>::quiet_NaN());
-      current_statement__ = 4;
+      current_statement__ = 1;
       p_vector = in__.template read<
                    Eigen::Matrix<local_scalar_t__,-1,1>>(d_int);
-      Eigen::Matrix<double,1,-1> p_row_vector =
-        Eigen::Matrix<double,1,-1>::Constant(d_int,
-          std::numeric_limits<double>::quiet_NaN());
-      current_statement__ = 5;
-      p_row_vector = in__.template read<
-                       Eigen::Matrix<local_scalar_t__,1,-1>>(d_int);
-      double y_p = std::numeric_limits<double>::quiet_NaN();
-      current_statement__ = 6;
-      y_p = in__.template read<local_scalar_t__>();
       double transformed_param_real =
         std::numeric_limits<double>::quiet_NaN();
-      out__.write(p_real);
-      out__.write(p_real_array);
-      out__.write(p_matrix);
       out__.write(p_vector);
-      out__.write(p_row_vector);
-      out__.write(y_p);
       if (stan::math::logical_negation(
             (stan::math::primitive_value(emit_transformed_parameters__) ||
             stan::math::primitive_value(emit_generated_quantities__)))) {
         return ;
       }
-      current_statement__ = 8;
-      transformed_param_real = stan::math::bernoulli_lpmf<false>(d_int_array,
-                                 d_real);
-      current_statement__ = 9;
-      transformed_param_real = stan::math::bernoulli_lpmf<false>(d_int_array,
-                                 p_real);
-      current_statement__ = 10;
-      transformed_param_real = stan::math::exponential_lpdf<false>(p_vector,
-                                 d_real);
-      current_statement__ = 11;
-      transformed_param_real = stan::math::exponential_lpdf<false>(p_vector,
-                                 p_real);
-      current_statement__ = 12;
-      transformed_param_real = stan::math::std_normal_lpdf<false>(p_vector);
-      current_statement__ = 13;
-      transformed_param_real = stan::math::uniform_lpdf<false>(p_vector,
-                                 d_real, d_real);
-      current_statement__ = 14;
-      transformed_param_real = stan::math::uniform_lpdf<false>(p_vector,
-                                 d_real, p_real);
-      current_statement__ = 15;
-      transformed_param_real = stan::math::uniform_lpdf<false>(p_vector,
-                                 p_real, d_real);
-      current_statement__ = 16;
-      transformed_param_real = stan::math::uniform_lpdf<false>(p_vector,
-                                 p_real, p_real);
-      current_statement__ = 17;
-      transformed_param_real = stan::math::exponential_lpdf<false>(
-                                 d_vector_opencl__, d_real);
-      current_statement__ = 18;
-      transformed_param_real = stan::math::exponential_lpdf<false>(
-                                 d_vector_opencl__, p_real);
-      current_statement__ = 19;
-      transformed_param_real = stan::math::std_normal_lpdf<false>(
-                                 d_vector_opencl__);
-      current_statement__ = 20;
-      transformed_param_real = stan::math::uniform_lpdf<false>(
-                                 d_vector_opencl__, d_real, d_real);
-      current_statement__ = 21;
-      transformed_param_real = stan::math::uniform_lpdf<false>(
-                                 d_vector_opencl__, d_real, p_real);
-      current_statement__ = 22;
-      transformed_param_real = stan::math::uniform_lpdf<false>(
-                                 d_vector_opencl__, p_real, d_real);
-      current_statement__ = 23;
-      transformed_param_real = stan::math::uniform_lpdf<false>(
-                                 d_vector_opencl__, p_real, p_real);
+      current_statement__ = 3;
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(d_int,
+                                 p_vector);
+      current_statement__ = 4;
+      transformed_param_real = stan::math::bernoulli_logit_lpmf<false>(
+                                 d_int_array, p_vector);
       if (emit_transformed_parameters__) {
         out__.write(transformed_param_real);
       }
@@ -10967,43 +9591,13 @@ class restricted_model final : public model_base_crtp<restricted_model> {
     // suppress unused var warning
     (void) DUMMY_VAR__;
     try {
-      local_scalar_t__ p_real = DUMMY_VAR__;
-      current_statement__ = 1;
-      p_real = in__.read<local_scalar_t__>();
-      out__.write(p_real);
-      std::vector<local_scalar_t__> p_real_array =
-        std::vector<local_scalar_t__>(d_int, DUMMY_VAR__);
-      current_statement__ = 2;
-      stan::model::assign(p_real_array,
-        in__.read<std::vector<local_scalar_t__>>(d_int),
-        "assigning variable p_real_array");
-      out__.write(p_real_array);
-      Eigen::Matrix<local_scalar_t__,-1,-1> p_matrix =
-        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(d_int, d_int,
-          DUMMY_VAR__);
-      current_statement__ = 3;
-      stan::model::assign(p_matrix,
-        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(d_int, d_int),
-        "assigning variable p_matrix");
-      out__.write(p_matrix);
       Eigen::Matrix<local_scalar_t__,-1,1> p_vector =
         Eigen::Matrix<local_scalar_t__,-1,1>::Constant(d_int, DUMMY_VAR__);
-      current_statement__ = 4;
+      current_statement__ = 1;
       stan::model::assign(p_vector,
         in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(d_int),
         "assigning variable p_vector");
       out__.write(p_vector);
-      Eigen::Matrix<local_scalar_t__,1,-1> p_row_vector =
-        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(d_int, DUMMY_VAR__);
-      current_statement__ = 5;
-      stan::model::assign(p_row_vector,
-        in__.read<Eigen::Matrix<local_scalar_t__,1,-1>>(d_int),
-        "assigning variable p_row_vector");
-      out__.write(p_row_vector);
-      local_scalar_t__ y_p = DUMMY_VAR__;
-      current_statement__ = 6;
-      y_p = in__.read<local_scalar_t__>();
-      out__.write(y_p);
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
     }
@@ -11020,59 +9614,15 @@ class restricted_model final : public model_base_crtp<restricted_model> {
     (void) DUMMY_VAR__;
     try {
       current_statement__ = 1;
-      context__.validate_dims("parameter initialization", "p_real", "double",
-        std::vector<size_t>{});
-      current_statement__ = 2;
-      context__.validate_dims("parameter initialization", "p_real_array",
-        "double", std::vector<size_t>{static_cast<size_t>(d_int)});
-      current_statement__ = 3;
-      context__.validate_dims("parameter initialization", "p_matrix",
-        "double",
-        std::vector<size_t>{static_cast<size_t>(d_int),
-          static_cast<size_t>(d_int)});
-      current_statement__ = 4;
       context__.validate_dims("parameter initialization", "p_vector",
         "double", std::vector<size_t>{static_cast<size_t>(d_int)});
-      current_statement__ = 5;
-      context__.validate_dims("parameter initialization", "p_row_vector",
-        "double", std::vector<size_t>{static_cast<size_t>(d_int)});
-      current_statement__ = 6;
-      context__.validate_dims("parameter initialization", "y_p", "double",
-        std::vector<size_t>{});
       int pos__ = std::numeric_limits<int>::min();
       pos__ = 1;
-      local_scalar_t__ p_real = DUMMY_VAR__;
-      current_statement__ = 1;
-      p_real = context__.vals_r("p_real")[(1 - 1)];
-      out__.write(p_real);
-      std::vector<local_scalar_t__> p_real_array =
-        std::vector<local_scalar_t__>(d_int, DUMMY_VAR__);
-      current_statement__ = 2;
-      p_real_array = context__.vals_r("p_real_array");
-      out__.write(p_real_array);
-      Eigen::Matrix<local_scalar_t__,-1,-1> p_matrix =
-        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(d_int, d_int,
-          DUMMY_VAR__);
-      {
-        std::vector<local_scalar_t__> p_matrix_flat__;
-        current_statement__ = 3;
-        p_matrix_flat__ = context__.vals_r("p_matrix");
-        pos__ = 1;
-        for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
-          for (int sym2__ = 1; sym2__ <= d_int; ++sym2__) {
-            stan::model::assign(p_matrix, p_matrix_flat__[(pos__ - 1)],
-              "assigning variable p_matrix", stan::model::index_uni(sym2__),
-              stan::model::index_uni(sym1__));
-            pos__ = (pos__ + 1);
-          }
-        }
-      }
-      out__.write(p_matrix);
       Eigen::Matrix<local_scalar_t__,-1,1> p_vector =
         Eigen::Matrix<local_scalar_t__,-1,1>::Constant(d_int, DUMMY_VAR__);
       {
         std::vector<local_scalar_t__> p_vector_flat__;
-        current_statement__ = 4;
+        current_statement__ = 1;
         p_vector_flat__ = context__.vals_r("p_vector");
         pos__ = 1;
         for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
@@ -11082,24 +9632,6 @@ class restricted_model final : public model_base_crtp<restricted_model> {
         }
       }
       out__.write(p_vector);
-      Eigen::Matrix<local_scalar_t__,1,-1> p_row_vector =
-        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(d_int, DUMMY_VAR__);
-      {
-        std::vector<local_scalar_t__> p_row_vector_flat__;
-        current_statement__ = 5;
-        p_row_vector_flat__ = context__.vals_r("p_row_vector");
-        pos__ = 1;
-        for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
-          stan::model::assign(p_row_vector, p_row_vector_flat__[(pos__ - 1)],
-            "assigning variable p_row_vector", stan::model::index_uni(sym1__));
-          pos__ = (pos__ + 1);
-        }
-      }
-      out__.write(p_row_vector);
-      local_scalar_t__ y_p = DUMMY_VAR__;
-      current_statement__ = 6;
-      y_p = context__.vals_r("y_p")[(1 - 1)];
-      out__.write(y_p);
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
     }
@@ -11108,8 +9640,7 @@ class restricted_model final : public model_base_crtp<restricted_model> {
   get_param_names(std::vector<std::string>& names__, const bool
                   emit_transformed_parameters__ = true, const bool
                   emit_generated_quantities__ = true) const {
-    names__ = std::vector<std::string>{"p_real", "p_real_array", "p_matrix",
-                "p_vector", "p_row_vector", "y_p"};
+    names__ = std::vector<std::string>{"p_vector"};
     if (emit_transformed_parameters__) {
       std::vector<std::string> temp{"transformed_param_real"};
       names__.reserve(names__.size() + temp.size());
@@ -11121,13 +9652,9 @@ class restricted_model final : public model_base_crtp<restricted_model> {
   get_dims(std::vector<std::vector<size_t>>& dimss__, const bool
            emit_transformed_parameters__ = true, const bool
            emit_generated_quantities__ = true) const {
-    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{},
-                std::vector<size_t>{static_cast<size_t>(d_int)},
-                std::vector<size_t>{static_cast<size_t>(d_int),
-                  static_cast<size_t>(d_int)},
-                std::vector<size_t>{static_cast<size_t>(d_int)},
-                std::vector<size_t>{static_cast<size_t>(d_int)},
-                std::vector<size_t>{}};
+    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{static_cast<
+                                                                    size_t>(
+                                                                    d_int)}};
     if (emit_transformed_parameters__) {
       std::vector<std::vector<size_t>> temp{std::vector<size_t>{}};
       dimss__.reserve(dimss__.size() + temp.size());
@@ -11139,26 +9666,10 @@ class restricted_model final : public model_base_crtp<restricted_model> {
   constrained_param_names(std::vector<std::string>& param_names__, bool
                           emit_transformed_parameters__ = true, bool
                           emit_generated_quantities__ = true) const final {
-    param_names__.emplace_back(std::string() + "p_real");
-    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
-      param_names__.emplace_back(std::string() + "p_real_array" + '.' +
-        std::to_string(sym1__));
-    }
-    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
-      for (int sym2__ = 1; sym2__ <= d_int; ++sym2__) {
-        param_names__.emplace_back(std::string() + "p_matrix" + '.' +
-          std::to_string(sym2__) + '.' + std::to_string(sym1__));
-      }
-    }
     for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
       param_names__.emplace_back(std::string() + "p_vector" + '.' +
         std::to_string(sym1__));
     }
-    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
-      param_names__.emplace_back(std::string() + "p_row_vector" + '.' +
-        std::to_string(sym1__));
-    }
-    param_names__.emplace_back(std::string() + "y_p");
     if (emit_transformed_parameters__) {
       param_names__.emplace_back(std::string() + "transformed_param_real");
     }
@@ -11168,36 +9679,20 @@ class restricted_model final : public model_base_crtp<restricted_model> {
   unconstrained_param_names(std::vector<std::string>& param_names__, bool
                             emit_transformed_parameters__ = true, bool
                             emit_generated_quantities__ = true) const final {
-    param_names__.emplace_back(std::string() + "p_real");
-    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
-      param_names__.emplace_back(std::string() + "p_real_array" + '.' +
-        std::to_string(sym1__));
-    }
-    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
-      for (int sym2__ = 1; sym2__ <= d_int; ++sym2__) {
-        param_names__.emplace_back(std::string() + "p_matrix" + '.' +
-          std::to_string(sym2__) + '.' + std::to_string(sym1__));
-      }
-    }
     for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
       param_names__.emplace_back(std::string() + "p_vector" + '.' +
         std::to_string(sym1__));
     }
-    for (int sym1__ = 1; sym1__ <= d_int; ++sym1__) {
-      param_names__.emplace_back(std::string() + "p_row_vector" + '.' +
-        std::to_string(sym1__));
-    }
-    param_names__.emplace_back(std::string() + "y_p");
     if (emit_transformed_parameters__) {
       param_names__.emplace_back(std::string() + "transformed_param_real");
     }
     if (emit_generated_quantities__) {}
   }
   inline std::string get_constrained_sizedtypes() const {
-    return std::string("[{\"name\":\"p_real\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"p_real_array\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(d_int) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"p_matrix\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(d_int) + ",\"cols\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"p_vector\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"p_row_vector\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"y_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"transformed_param_real\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]");
+    return std::string("[{\"name\":\"p_vector\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"transformed_param_real\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]");
   }
   inline std::string get_unconstrained_sizedtypes() const {
-    return std::string("[{\"name\":\"p_real\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"p_real_array\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(d_int) + ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"p_matrix\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(d_int) + ",\"cols\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"p_vector\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"p_row_vector\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"y_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"transformed_param_real\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]");
+    return std::string("[{\"name\":\"p_vector\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(d_int) + "},\"block\":\"parameters\"},{\"name\":\"transformed_param_real\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]");
   }
   // Begin method overload boilerplate
   template <typename RNG> inline void
@@ -11206,8 +9701,7 @@ class restricted_model final : public model_base_crtp<restricted_model> {
               emit_transformed_parameters = true, const bool
               emit_generated_quantities = true, std::ostream*
               pstream = nullptr) const {
-    const size_t num_params__ = (((((1 + d_int) + (d_int * d_int)) + d_int) +
-      d_int) + 1);
+    const size_t num_params__ = d_int;
     const size_t num_transformed = emit_transformed_parameters * (1);
     const size_t num_gen_quantities = emit_generated_quantities * (0);
     const size_t num_to_write = num_params__ + num_transformed +
@@ -11224,8 +9718,7 @@ class restricted_model final : public model_base_crtp<restricted_model> {
               emit_transformed_parameters = true, bool
               emit_generated_quantities = true, std::ostream*
               pstream = nullptr) const {
-    const size_t num_params__ = (((((1 + d_int) + (d_int * d_int)) + d_int) +
-      d_int) + 1);
+    const size_t num_params__ = d_int;
     const size_t num_transformed = emit_transformed_parameters * (1);
     const size_t num_gen_quantities = emit_generated_quantities * (0);
     const size_t num_to_write = num_params__ + num_transformed +
@@ -11284,7 +9777,7 @@ class restricted_model final : public model_base_crtp<restricted_model> {
   }
 };
 }
-using stan_model = restricted_model_namespace::restricted_model;
+using stan_model = tiny_model_namespace::tiny_model;
 #ifndef USING_R
 // Boilerplate
 stan::model::model_base&
@@ -11294,6 +9787,6 @@ new_model(stan::io::var_context& data_context, unsigned int seed,
   return *m;
 }
 stan::math::profile_map& get_stan_profile_data() {
-  return restricted_model_namespace::profiles__;
+  return tiny_model_namespace::profiles__;
 }
 #endif
diff --git a/test/integration/good/code-gen/opencl/tiny.stan b/test/integration/good/code-gen/opencl/tiny.stan
new file mode 100644
index 000000000..4fb6a853f
--- /dev/null
+++ b/test/integration/good/code-gen/opencl/tiny.stan
@@ -0,0 +1,12 @@
+data {
+  int d_int;
+  array[d_int] int d_int_array;
+}
+parameters {
+  vector[d_int] p_vector;
+}
+transformed parameters {
+  real transformed_param_real;
+  transformed_param_real = bernoulli_logit_lpmf(d_int| p_vector);
+  transformed_param_real = bernoulli_logit_lpmf(d_int_array| p_vector);
+}
\ No newline at end of file
diff --git a/test/integration/good/code-gen/profiling/transformed_mir.expected b/test/integration/good/code-gen/profiling/transformed_mir.expected
index c55c98aad..978d4d163 100644
--- a/test/integration/good/code-gen/profiling/transformed_mir.expected
+++ b/test/integration/good/code-gen/profiling/transformed_mir.expected
@@ -6,13 +6,13 @@
       ((filename simple_function.stan) (line_num 2) (col_num 2) (included_from ())))
      (end_loc
       ((filename simple_function.stan) (line_num 2) (col_num 17) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (x
     ((begin_loc
       ((filename simple_function.stan) (line_num 3) (col_num 2) (included_from ())))
      (end_loc
       ((filename simple_function.stan) (line_num 3) (col_num 18) (included_from ()))))
-    (SArray SReal
+    (SArray AoS (SReal AoS)
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (y
     ((begin_loc
@@ -23,7 +23,7 @@
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -31,7 +31,8 @@
       ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable N) ()) UInt
@@ -68,7 +69,7 @@
      (Decl (decl_adtype DataOnly) (decl_id x)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -152,7 +153,7 @@
         (meta <opaque>)))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id sum_y) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id sum_y) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -168,7 +169,7 @@
     (meta <opaque>))))
  (log_prob
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id rho) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id rho) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -186,7 +187,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -204,7 +205,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -405,7 +406,7 @@
     (meta <opaque>))))
  (reverse_mode_log_prob
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id rho) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id rho) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -423,7 +424,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -441,7 +442,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -642,7 +643,7 @@
     (meta <opaque>))))
  (generate_quantities
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id rho) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id rho) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -660,7 +661,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -678,7 +679,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id sigma) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id sigma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -744,7 +745,7 @@
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id rho) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id rho) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -774,7 +775,7 @@
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -804,7 +805,7 @@
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -835,7 +836,7 @@
     (meta <opaque>))))
  (unconstrain_array
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id rho) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id rho) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -856,7 +857,7 @@
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -877,7 +878,7 @@
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -903,7 +904,8 @@
       ((filename simple_function.stan) (line_num 13) (col_num 2) (included_from ())))
      (end_loc
       ((filename simple_function.stan) (line_num 13) (col_num 20) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters)
      (out_trans
       (Lower
        ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
@@ -912,7 +914,8 @@
       ((filename simple_function.stan) (line_num 14) (col_num 2) (included_from ())))
      (end_loc
       ((filename simple_function.stan) (line_num 14) (col_num 22) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters)
      (out_trans
       (Lower
        ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
@@ -921,7 +924,8 @@
       ((filename simple_function.stan) (line_num 15) (col_num 2) (included_from ())))
      (end_loc
       ((filename simple_function.stan) (line_num 15) (col_num 22) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters)
      (out_trans
       (Lower
        ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))))
diff --git a/test/integration/good/code-gen/transformed_mir.expected b/test/integration/good/code-gen/transformed_mir.expected
index ffb30e428..2b3c9c9d4 100644
--- a/test/integration/good/code-gen/transformed_mir.expected
+++ b/test/integration/good/code-gen/transformed_mir.expected
@@ -56,7 +56,7 @@
             (Decl (decl_adtype AutoDiffable) (decl_id dydt)
              (decl_type
               (Sized
-               (SArray SReal
+               (SArray AoS (SReal AoS)
                 ((pattern (Lit Int 2))
                  (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
              (initialize true)))
@@ -336,8 +336,8 @@
              ((pattern
                (Block
                 (((pattern
-                   (Decl (decl_adtype AutoDiffable) (decl_id b) (decl_type (Sized SInt))
-                    (initialize true)))
+                   (Decl (decl_adtype AutoDiffable) (decl_id b)
+                    (decl_type (Sized (SInt AoS))) (initialize true)))
                   (meta <opaque>))
                  ((pattern
                    (Assignment ((LVariable b) ()) UInt
@@ -419,8 +419,8 @@
                    (Decl (decl_adtype AutoDiffable) (decl_id vs)
                     (decl_type
                      (Sized
-                      (SArray
-                       (SArray SInt
+                      (SArray AoS
+                       (SArray AoS (SInt AoS)
                         ((pattern (Lit Int 3))
                          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
                        ((pattern (Lit Int 2))
@@ -428,8 +428,8 @@
                     (initialize true)))
                   (meta <opaque>))
                  ((pattern
-                   (Decl (decl_adtype AutoDiffable) (decl_id z) (decl_type (Sized SInt))
-                    (initialize true)))
+                   (Decl (decl_adtype AutoDiffable) (decl_id z)
+                    (decl_type (Sized (SInt AoS))) (initialize true)))
                   (meta <opaque>))
                  ((pattern
                    (For (loopvar sym1__)
@@ -631,8 +631,8 @@
              ((pattern
                (Block
                 (((pattern
-                   (Decl (decl_adtype AutoDiffable) (decl_id z) (decl_type (Sized SReal))
-                    (initialize true)))
+                   (Decl (decl_adtype AutoDiffable) (decl_id z)
+                    (decl_type (Sized (SReal AoS))) (initialize true)))
                   (meta <opaque>))
                  ((pattern
                    (Decl (decl_adtype AutoDiffable) (decl_id vs)
@@ -822,8 +822,8 @@
              ((pattern
                (Block
                 (((pattern
-                   (Decl (decl_adtype AutoDiffable) (decl_id z) (decl_type (Sized SReal))
-                    (initialize true)))
+                   (Decl (decl_adtype AutoDiffable) (decl_id z)
+                    (decl_type (Sized (SReal AoS))) (initialize true)))
                   (meta <opaque>))
                  ((pattern
                    (Decl (decl_adtype AutoDiffable) (decl_id vs)
@@ -938,8 +938,8 @@
              ((pattern
                (Block
                 (((pattern
-                   (Decl (decl_adtype AutoDiffable) (decl_id z) (decl_type (Sized SReal))
-                    (initialize true)))
+                   (Decl (decl_adtype AutoDiffable) (decl_id z)
+                    (decl_type (Sized (SReal AoS))) (initialize true)))
                   (meta <opaque>))
                  ((pattern
                    (Decl (decl_adtype AutoDiffable) (decl_id vs)
@@ -1056,8 +1056,8 @@
              ((pattern
                (Block
                 (((pattern
-                   (Decl (decl_adtype AutoDiffable) (decl_id b) (decl_type (Sized SInt))
-                    (initialize true)))
+                   (Decl (decl_adtype AutoDiffable) (decl_id b)
+                    (decl_type (Sized (SInt AoS))) (initialize true)))
                   (meta <opaque>))
                  ((pattern
                    (Assignment ((LVariable b) ()) UInt
@@ -1068,7 +1068,7 @@
                    (Block
                     (((pattern
                        (Decl (decl_adtype AutoDiffable) (decl_id c)
-                        (decl_type (Sized SInt)) (initialize true)))
+                        (decl_type (Sized (SInt AoS))) (initialize true)))
                       (meta <opaque>))
                      ((pattern
                        (Assignment ((LVariable c) ()) UInt
@@ -1095,13 +1095,13 @@
             (Decl (decl_adtype AutoDiffable) (decl_id vs)
              (decl_type
               (Sized
-               (SArray SInt
+               (SArray AoS (SInt AoS)
                 ((pattern (Lit Int 2))
                  (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
              (initialize true)))
            (meta <opaque>))
           ((pattern
-            (Decl (decl_adtype AutoDiffable) (decl_id y) (decl_type (Sized SInt))
+            (Decl (decl_adtype AutoDiffable) (decl_id y) (decl_type (Sized (SInt AoS)))
              (initialize true)))
            (meta <opaque>))
           ((pattern
@@ -1217,12 +1217,12 @@
      (((pattern
         (Block
          (((pattern
-            (Decl (decl_adtype AutoDiffable) (decl_id abs_diff) (decl_type (Sized SReal))
-             (initialize true)))
+            (Decl (decl_adtype AutoDiffable) (decl_id abs_diff)
+             (decl_type (Sized (SReal AoS))) (initialize true)))
            (meta <opaque>))
           ((pattern
             (Decl (decl_adtype AutoDiffable) (decl_id avg_scale)
-             (decl_type (Sized SReal)) (initialize true)))
+             (decl_type (Sized (SReal AoS))) (initialize true)))
            (meta <opaque>))
           ((pattern
             (Assignment ((LVariable abs_diff) ()) UReal
@@ -1746,19 +1746,19 @@
      (((pattern
         (Block
          (((pattern
-            (Decl (decl_adtype AutoDiffable) (decl_id a) (decl_type (Sized SInt))
+            (Decl (decl_adtype AutoDiffable) (decl_id a) (decl_type (Sized (SInt AoS)))
              (initialize true)))
            (meta <opaque>))
           ((pattern
-            (Decl (decl_adtype AutoDiffable) (decl_id b) (decl_type (Sized SReal))
+            (Decl (decl_adtype AutoDiffable) (decl_id b) (decl_type (Sized (SReal AoS)))
              (initialize true)))
            (meta <opaque>))
           ((pattern
             (Decl (decl_adtype AutoDiffable) (decl_id c)
              (decl_type
               (Sized
-               (SArray
-                (SArray SReal
+               (SArray AoS
+                (SArray AoS (SReal AoS)
                  ((pattern (Lit Int 30))
                   (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
                 ((pattern (Lit Int 20))
@@ -1769,8 +1769,8 @@
             (Decl (decl_adtype AutoDiffable) (decl_id ar_mat)
              (decl_type
               (Sized
-               (SArray
-                (SArray
+               (SArray AoS
+                (SArray AoS
                  (SMatrix AoS
                   ((pattern (Lit Int 40))
                    (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -2460,44 +2460,44 @@
   ((N
     ((begin_loc ((filename mother.stan) (line_num 348) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 348) (col_num 17) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (M
     ((begin_loc ((filename mother.stan) (line_num 349) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 349) (col_num 17) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (K
     ((begin_loc ((filename mother.stan) (line_num 350) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 350) (col_num 30) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (d_int_1d_ar
     ((begin_loc ((filename mother.stan) (line_num 351) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 351) (col_num 36) (included_from ()))))
-    (SArray SInt
+    (SArray AoS (SInt AoS)
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_int_3d_ar
     ((begin_loc ((filename mother.stan) (line_num 352) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 352) (col_num 42) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray SInt
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS (SInt AoS)
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
       ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (J
     ((begin_loc ((filename mother.stan) (line_num 353) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 353) (col_num 32) (included_from ()))))
-    SReal)
+    (SReal AoS))
    (d_real_1d_ar
     ((begin_loc ((filename mother.stan) (line_num 354) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 354) (col_num 29) (included_from ()))))
-    (SArray SReal
+    (SArray AoS (SReal AoS)
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_real_3d_ar
     ((begin_loc ((filename mother.stan) (line_num 355) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 355) (col_num 35) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray SReal
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS (SReal AoS)
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
       ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -2509,16 +2509,16 @@
    (d_1d_vec
     ((begin_loc ((filename mother.stan) (line_num 357) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 357) (col_num 30) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SVector AoS
       ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_3d_vec
     ((begin_loc ((filename mother.stan) (line_num 358) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 358) (col_num 36) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2532,16 +2532,16 @@
    (d_1d_row_vec
     ((begin_loc ((filename mother.stan) (line_num 360) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 360) (col_num 38) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SRowVector AoS
       ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_3d_row_vec
     ((begin_loc ((filename mother.stan) (line_num 361) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 361) (col_num 44) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2550,8 +2550,8 @@
    (d_ar_mat
     ((begin_loc ((filename mother.stan) (line_num 362) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 362) (col_num 54) (included_from ()))))
-    (SArray
-     (SArray
+    (SArray AoS
+     (SArray AoS
       (SMatrix AoS
        ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2565,16 +2565,16 @@
    (d_1d_simplex
     ((begin_loc ((filename mother.stan) (line_num 364) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 364) (col_num 35) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SVector AoS
       ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_3d_simplex
     ((begin_loc ((filename mother.stan) (line_num 365) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 365) (col_num 41) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2595,7 +2595,7 @@
    (d_cfcov_33_ar
     ((begin_loc ((filename mother.stan) (line_num 368) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 368) (col_num 48) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SMatrix AoS
       ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
       ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2603,50 +2603,50 @@
    (d_int
     ((begin_loc ((filename mother.stan) (line_num 369) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 369) (col_num 12) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (d_int_array
     ((begin_loc ((filename mother.stan) (line_num 370) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 370) (col_num 31) (included_from ()))))
-    (SArray SInt
+    (SArray AoS (SInt AoS)
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_int_array_2d
     ((begin_loc ((filename mother.stan) (line_num 371) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 371) (col_num 37) (included_from ()))))
-    (SArray
-     (SArray SInt
+    (SArray AoS
+     (SArray AoS (SInt AoS)
       ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_int_array_3d
     ((begin_loc ((filename mother.stan) (line_num 372) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 372) (col_num 40) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray SInt
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS (SInt AoS)
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
       ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_real
     ((begin_loc ((filename mother.stan) (line_num 373) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 373) (col_num 14) (included_from ()))))
-    SReal)
+    (SReal AoS))
    (d_real_array
     ((begin_loc ((filename mother.stan) (line_num 374) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 374) (col_num 33) (included_from ()))))
-    (SArray SReal
+    (SArray AoS (SReal AoS)
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_real_array_2d
     ((begin_loc ((filename mother.stan) (line_num 375) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 375) (col_num 39) (included_from ()))))
-    (SArray
-     (SArray SReal
+    (SArray AoS
+     (SArray AoS (SReal AoS)
       ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_real_array_3d
     ((begin_loc ((filename mother.stan) (line_num 376) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 376) (col_num 42) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray SReal
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
       ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -2659,7 +2659,7 @@
    (d_matrix_array
     ((begin_loc ((filename mother.stan) (line_num 378) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 378) (col_num 51) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SMatrix AoS
       ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
       ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2667,8 +2667,8 @@
    (d_matrix_array_2d
     ((begin_loc ((filename mother.stan) (line_num 379) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 379) (col_num 57) (included_from ()))))
-    (SArray
-     (SArray
+    (SArray AoS
+     (SArray AoS
       (SMatrix AoS
        ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
        ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2677,9 +2677,9 @@
    (d_matrix_array_3d
     ((begin_loc ((filename mother.stan) (line_num 380) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 380) (col_num 60) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2694,15 +2694,15 @@
    (d_vector_array
     ((begin_loc ((filename mother.stan) (line_num 382) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 382) (col_num 44) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SVector AoS
       ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_vector_array_2d
     ((begin_loc ((filename mother.stan) (line_num 383) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 383) (col_num 50) (included_from ()))))
-    (SArray
-     (SArray
+    (SArray AoS
+     (SArray AoS
       (SVector AoS
        ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
       ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2710,9 +2710,9 @@
    (d_vector_array_3d
     ((begin_loc ((filename mother.stan) (line_num 384) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 384) (col_num 53) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS
        (SVector AoS
         ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2726,15 +2726,15 @@
    (d_row_vector_array
     ((begin_loc ((filename mother.stan) (line_num 386) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 386) (col_num 52) (included_from ()))))
-    (SArray
+    (SArray AoS
      (SRowVector AoS
       ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (d_row_vector_array_2d
     ((begin_loc ((filename mother.stan) (line_num 387) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 387) (col_num 58) (included_from ()))))
-    (SArray
-     (SArray
+    (SArray AoS
+     (SArray AoS
       (SRowVector AoS
        ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
       ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2742,9 +2742,9 @@
    (d_row_vector_array_3d
     ((begin_loc ((filename mother.stan) (line_num 388) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 388) (col_num 61) (included_from ()))))
-    (SArray
-     (SArray
-      (SArray
+    (SArray AoS
+     (SArray AoS
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -2752,7 +2752,7 @@
      ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -2760,7 +2760,8 @@
       ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable N) ()) UInt
@@ -2788,7 +2789,8 @@
       (((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id M) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id M) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable M) ()) UInt
@@ -2816,7 +2818,8 @@
       (((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id K) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id K) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable K) ()) UInt
@@ -2873,7 +2876,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_int_1d_ar)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -2923,9 +2926,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_int_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SInt
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SInt AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -3047,7 +3050,7 @@
       (((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id J) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id J) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3109,7 +3112,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -3146,9 +3149,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -3345,7 +3348,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -3457,9 +3460,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -3686,7 +3689,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -3798,9 +3801,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -3941,8 +3944,8 @@
      (Decl (decl_adtype DataOnly) (decl_id d_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -4206,7 +4209,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -4327,9 +4330,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -4673,7 +4676,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -4790,7 +4793,7 @@
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id d_int) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id d_int) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -4819,7 +4822,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_int_array)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -4843,8 +4846,8 @@
      (Decl (decl_adtype DataOnly) (decl_id d_int_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray SInt
+        (SArray AoS
+         (SArray AoS (SInt AoS)
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -4936,9 +4939,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_int_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SInt
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SInt AoS)
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -5048,7 +5051,7 @@
         (meta <opaque>)))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id d_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id d_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -5077,7 +5080,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_real_array)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -5101,8 +5104,8 @@
      (Decl (decl_adtype DataOnly) (decl_id d_real_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray SReal
+        (SArray AoS
+         (SArray AoS (SReal AoS)
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -5194,9 +5197,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_real_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -5433,7 +5436,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_matrix_array)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -5568,8 +5571,8 @@
      (Decl (decl_adtype DataOnly) (decl_id d_matrix_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Var d_int))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -5736,9 +5739,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_matrix_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SMatrix AoS
             ((pattern (Var d_int))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -6006,7 +6009,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_vector_array)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -6107,8 +6110,8 @@
      (Decl (decl_adtype DataOnly) (decl_id d_vector_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SVector AoS
            ((pattern (Var d_int))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -6237,9 +6240,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_vector_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var d_int))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -6473,7 +6476,7 @@
      (Decl (decl_adtype DataOnly) (decl_id d_row_vector_array)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -6574,8 +6577,8 @@
      (Decl (decl_adtype DataOnly) (decl_id d_row_vector_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SRowVector AoS
            ((pattern (Var d_int))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -6704,9 +6707,9 @@
      (Decl (decl_adtype DataOnly) (decl_id d_row_vector_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var d_int))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -6848,7 +6851,7 @@
         (meta <opaque>)))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id td_int) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id td_int) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -6862,7 +6865,7 @@
      (Decl (decl_adtype DataOnly) (decl_id td_1d)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -6877,7 +6880,7 @@
      (Decl (decl_adtype DataOnly) (decl_id td_1dk)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -6890,7 +6893,7 @@
        (meta ((type_ (UArray UInt)) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id td_a) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id td_a) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -6898,7 +6901,7 @@
       ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id td_b) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id td_b) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -6914,7 +6917,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id td_c) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id td_c) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -6928,8 +6931,8 @@
      (Decl (decl_adtype DataOnly) (decl_id td_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -6972,7 +6975,7 @@
      (Decl (decl_adtype DataOnly) (decl_id td_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -7010,9 +7013,9 @@
      (Decl (decl_adtype DataOnly) (decl_id td_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -7058,7 +7061,7 @@
      (Decl (decl_adtype DataOnly) (decl_id dat)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -7066,7 +7069,7 @@
      (Decl (decl_adtype DataOnly) (decl_id dat_int)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -7074,8 +7077,8 @@
      (Decl (decl_adtype DataOnly) (decl_id x_r)
       (decl_type
        (Sized
-        (SArray
-         (SArray SReal
+        (SArray AoS
+         (SArray AoS (SReal AoS)
           ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -7084,8 +7087,8 @@
      (Decl (decl_adtype DataOnly) (decl_id x_i)
       (decl_type
        (Sized
-        (SArray
-         (SArray SInt
+        (SArray AoS
+         (SArray AoS (SInt AoS)
           ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -7426,7 +7429,7 @@
    ((pattern
      (Block
       (((pattern
-         (Decl (decl_adtype DataOnly) (decl_id z) (decl_type (Sized SReal))
+         (Decl (decl_adtype DataOnly) (decl_id z) (decl_type (Sized (SReal AoS)))
           (initialize true)))
         (meta <opaque>))
        ((pattern
@@ -7485,7 +7488,7 @@
          (Decl (decl_adtype DataOnly) (decl_id indices)
           (decl_type
            (Sized
-            (SArray SInt
+            (SArray AoS (SInt AoS)
              ((pattern (Lit Int 4))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
           (initialize true)))
@@ -7623,8 +7626,8 @@
      (Decl (decl_adtype DataOnly) (decl_id arr_mul_ind)
       (decl_type
        (Sized
-        (SArray
-         (SArray SInt
+        (SArray AoS
+         (SArray AoS (SInt AoS)
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -7648,7 +7651,7 @@
      (Decl (decl_adtype DataOnly) (decl_id x_mul_ind)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -7672,7 +7675,7 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_real)
-      (decl_type (Sized SReal)) (initialize true)))
+      (decl_type (Sized (SReal AoS))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (NRFunApp (CompilerInternal FnValidateSize)
@@ -7686,7 +7689,7 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_real_array)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -7702,8 +7705,8 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_real_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray SReal
+        (SArray AoS
+         (SArray AoS (SReal AoS)
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -7720,9 +7723,9 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_real_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -7782,7 +7785,7 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_matrix_array)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -7817,8 +7820,8 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_matrix_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Var d_int))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -7856,9 +7859,9 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_matrix_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SMatrix AoS
             ((pattern (Var d_int))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -7906,7 +7909,7 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_vector_array)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -7932,8 +7935,8 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_vector_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SVector AoS
            ((pattern (Var d_int))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -7961,9 +7964,9 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_vector_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var d_int))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -8009,7 +8012,7 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_row_vector_array)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var d_int)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -8035,8 +8038,8 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_row_vector_array_2d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SRowVector AoS
            ((pattern (Var d_int))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -8064,9 +8067,9 @@
      (Decl (decl_adtype DataOnly) (decl_id transformed_data_row_vector_array_3d)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var d_int))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -9844,7 +9847,7 @@
     (meta <opaque>))))
  (log_prob
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -9857,7 +9860,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_upper) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_upper) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -9875,7 +9878,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_lower) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_lower) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -9896,7 +9899,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -9923,7 +9926,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id no_offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -9948,7 +9951,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id offset_no_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -9973,7 +9976,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -9997,9 +10000,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -10052,7 +10055,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -10075,9 +10078,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -10126,7 +10129,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -10149,9 +10152,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -10204,8 +10207,8 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -10264,7 +10267,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -10287,9 +10290,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -10366,7 +10369,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -10435,7 +10438,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -10443,9 +10446,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -10463,7 +10466,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -10473,9 +10476,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -10495,7 +10498,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -10505,9 +10508,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -10528,8 +10531,8 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -10551,7 +10554,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -10561,9 +10564,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -10593,7 +10596,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -10609,7 +10612,7 @@
       (initialize true)))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id tp_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id tp_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -11177,7 +11180,7 @@
          (Decl (decl_adtype AutoDiffable) (decl_id tmp2)
           (decl_type
            (Sized
-            (SArray
+            (SArray AoS
              (SVector AoS
               ((pattern (Lit Int 0))
                (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11186,7 +11189,7 @@
           (initialize true)))
         (meta <opaque>))
        ((pattern
-         (Decl (decl_adtype AutoDiffable) (decl_id r1) (decl_type (Sized SReal))
+         (Decl (decl_adtype AutoDiffable) (decl_id r1) (decl_type (Sized (SReal AoS)))
           (initialize true)))
         (meta <opaque>))
        ((pattern
@@ -11198,7 +11201,7 @@
            (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
         (meta <opaque>))
        ((pattern
-         (Decl (decl_adtype AutoDiffable) (decl_id r2) (decl_type (Sized SReal))
+         (Decl (decl_adtype AutoDiffable) (decl_id r2) (decl_type (Sized (SReal AoS)))
           (initialize true)))
         (meta <opaque>))
        ((pattern
@@ -11962,7 +11965,7 @@
     (meta <opaque>))))
  (reverse_mode_log_prob
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -11975,7 +11978,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_upper) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_upper) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -11993,7 +11996,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_lower) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_lower) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -12014,7 +12017,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -12041,7 +12044,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id no_offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -12066,7 +12069,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id offset_no_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -12091,7 +12094,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -12115,9 +12118,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -12170,7 +12173,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -12193,9 +12196,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -12244,7 +12247,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -12267,9 +12270,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -12322,8 +12325,8 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -12382,7 +12385,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -12405,9 +12408,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -12484,7 +12487,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -12553,7 +12556,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -12561,9 +12564,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -12581,7 +12584,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -12591,9 +12594,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -12613,7 +12616,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -12623,9 +12626,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -12646,8 +12649,8 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -12669,7 +12672,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -12679,9 +12682,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -12711,7 +12714,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id tp_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -12727,7 +12730,7 @@
       (initialize true)))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id tp_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id tp_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -13295,7 +13298,7 @@
          (Decl (decl_adtype AutoDiffable) (decl_id tmp2)
           (decl_type
            (Sized
-            (SArray
+            (SArray AoS
              (SVector AoS
               ((pattern (Lit Int 0))
                (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -13304,7 +13307,7 @@
           (initialize true)))
         (meta <opaque>))
        ((pattern
-         (Decl (decl_adtype AutoDiffable) (decl_id r1) (decl_type (Sized SReal))
+         (Decl (decl_adtype AutoDiffable) (decl_id r1) (decl_type (Sized (SReal AoS)))
           (initialize true)))
         (meta <opaque>))
        ((pattern
@@ -13316,7 +13319,7 @@
            (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
         (meta <opaque>))
        ((pattern
-         (Decl (decl_adtype AutoDiffable) (decl_id r2) (decl_type (Sized SReal))
+         (Decl (decl_adtype AutoDiffable) (decl_id r2) (decl_type (Sized (SReal AoS)))
           (initialize true)))
         (meta <opaque>))
        ((pattern
@@ -14080,7 +14083,7 @@
     (meta <opaque>))))
  (generate_quantities
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id p_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id p_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -14093,7 +14096,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id p_upper) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id p_upper) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -14111,7 +14114,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id p_lower) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id p_lower) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -14132,7 +14135,7 @@
      (Decl (decl_adtype DataOnly) (decl_id offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -14159,7 +14162,7 @@
      (Decl (decl_adtype DataOnly) (decl_id no_offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -14184,7 +14187,7 @@
      (Decl (decl_adtype DataOnly) (decl_id offset_no_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -14209,7 +14212,7 @@
      (Decl (decl_adtype DataOnly) (decl_id p_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -14233,9 +14236,9 @@
      (Decl (decl_adtype DataOnly) (decl_id p_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -14288,7 +14291,7 @@
      (Decl (decl_adtype DataOnly) (decl_id p_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -14311,9 +14314,9 @@
      (Decl (decl_adtype DataOnly) (decl_id p_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -14362,7 +14365,7 @@
      (Decl (decl_adtype DataOnly) (decl_id p_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -14385,9 +14388,9 @@
      (Decl (decl_adtype DataOnly) (decl_id p_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -14440,8 +14443,8 @@
      (Decl (decl_adtype DataOnly) (decl_id p_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -14500,7 +14503,7 @@
      (Decl (decl_adtype DataOnly) (decl_id p_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -14523,9 +14526,9 @@
      (Decl (decl_adtype DataOnly) (decl_id p_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -14602,7 +14605,7 @@
      (Decl (decl_adtype DataOnly) (decl_id p_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -14671,7 +14674,7 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -14679,9 +14682,9 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -14699,7 +14702,7 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -14709,9 +14712,9 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -14731,7 +14734,7 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -14741,9 +14744,9 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -14764,8 +14767,8 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -14787,7 +14790,7 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -14797,9 +14800,9 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -14829,7 +14832,7 @@
      (Decl (decl_adtype DataOnly) (decl_id tp_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -14845,7 +14848,7 @@
       (initialize true)))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id tp_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id tp_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16900,7 +16903,7 @@
       ((pattern (Block (((pattern (Return ())) (meta <opaque>))))) (meta <opaque>)) ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id gq_r1) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id gq_r1) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16912,7 +16915,7 @@
        (meta ((type_ UReal) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id gq_r2) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id gq_r2) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16926,7 +16929,7 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -16934,9 +16937,9 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -16954,7 +16957,7 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -16964,9 +16967,9 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -16986,7 +16989,7 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -16996,9 +16999,9 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -17010,8 +17013,8 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -17033,7 +17036,7 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -17043,9 +17046,9 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -17075,7 +17078,7 @@
      (Decl (decl_adtype DataOnly) (decl_id gq_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -17086,7 +17089,7 @@
      (Decl (decl_adtype DataOnly) (decl_id indices)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -17103,7 +17106,7 @@
      (Decl (decl_adtype DataOnly) (decl_id indexing_mat)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -17114,7 +17117,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res1)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -17125,7 +17128,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res2)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -17136,7 +17139,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res3)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -17147,7 +17150,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res11)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -17158,7 +17161,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res21)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -17169,7 +17172,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res31)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -17180,7 +17183,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res4)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -17190,7 +17193,7 @@
      (Decl (decl_adtype DataOnly) (decl_id idx_res5)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -19245,7 +19248,7 @@
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -19253,7 +19256,7 @@
       ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -19280,7 +19283,7 @@
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_upper) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_upper) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -19311,7 +19314,7 @@
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_lower) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_lower) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -19345,7 +19348,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -19376,7 +19379,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id no_offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -19405,7 +19408,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id offset_no_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -19434,7 +19437,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -19463,9 +19466,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -19668,7 +19671,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -19761,9 +19764,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -19988,7 +19991,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -20081,9 +20084,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -20328,8 +20331,8 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -20561,7 +20564,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -20654,9 +20657,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -20993,7 +20996,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -21259,7 +21262,7 @@
     (meta <opaque>))))
  (unconstrain_array
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_real) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_real) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -21277,7 +21280,7 @@
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_upper) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_upper) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -21299,7 +21302,7 @@
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id p_lower) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id p_lower) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -21324,7 +21327,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -21354,7 +21357,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id no_offset_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -21382,7 +21385,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id offset_no_multiplier)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -21410,7 +21413,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_real_1d_ar)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -21438,9 +21441,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_real_3d_ar)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray SReal
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS (SReal AoS)
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -21546,7 +21549,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -21601,9 +21604,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -21728,7 +21731,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_row_vec)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -21783,9 +21786,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_row_vec)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SRowVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -21913,8 +21916,8 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_ar_mat)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (SMatrix AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -22047,7 +22050,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_1d_simplex)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -22102,9 +22105,9 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_3d_simplex)
       (decl_type
        (Sized
-        (SArray
-         (SArray
-          (SArray
+        (SArray AoS
+         (SArray AoS
+          (SArray AoS
            (SVector AoS
             ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -22257,7 +22260,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id p_cfcov_33_ar)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -22378,12 +22381,13 @@
   ((p_real
     ((begin_loc ((filename mother.stan) (line_num 599) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 599) (col_num 14) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
-     (out_trans Identity)))
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters) (out_trans Identity)))
    (p_upper
     ((begin_loc ((filename mother.stan) (line_num 600) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 600) (col_num 29) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters)
      (out_trans
       (Lower
        ((pattern (Var p_real))
@@ -22391,7 +22395,8 @@
    (p_lower
     ((begin_loc ((filename mother.stan) (line_num 601) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 601) (col_num 30) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters)
      (out_trans
       (Upper
        ((pattern (Var p_upper))
@@ -22400,10 +22405,10 @@
     ((begin_loc ((filename mother.stan) (line_num 602) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 602) (col_num 58) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block Parameters)
      (out_trans
@@ -22414,10 +22419,10 @@
     ((begin_loc ((filename mother.stan) (line_num 603) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 603) (col_num 51) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block Parameters)
      (out_trans
@@ -22427,10 +22432,10 @@
     ((begin_loc ((filename mother.stan) (line_num 604) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 604) (col_num 47) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block Parameters)
      (out_trans
@@ -22440,10 +22445,10 @@
     ((begin_loc ((filename mother.stan) (line_num 605) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 605) (col_num 38) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block Parameters)
      (out_trans
@@ -22453,16 +22458,16 @@
     ((begin_loc ((filename mother.stan) (line_num 606) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 606) (col_num 44) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray SReal
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS (SReal AoS)
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray SReal
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS (SReal AoS)
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -22487,12 +22492,12 @@
     ((begin_loc ((filename mother.stan) (line_num 608) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 608) (col_num 30) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -22501,18 +22506,18 @@
     ((begin_loc ((filename mother.stan) (line_num 609) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 609) (col_num 36) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -22533,12 +22538,12 @@
     ((begin_loc ((filename mother.stan) (line_num 611) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 611) (col_num 38) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -22547,18 +22552,18 @@
     ((begin_loc ((filename mother.stan) (line_num 612) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 612) (col_num 44) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -22581,16 +22586,16 @@
     ((begin_loc ((filename mother.stan) (line_num 614) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 614) (col_num 54) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (SMatrix AoS
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (SMatrix AoS
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -22620,7 +22625,7 @@
     ((begin_loc ((filename mother.stan) (line_num 616) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 616) (col_num 35) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern
           (FunApp (StanLib Minus__ FnPlain AoS)
@@ -22630,7 +22635,7 @@
          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -22639,9 +22644,9 @@
     ((begin_loc ((filename mother.stan) (line_num 617) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 617) (col_num 41) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern
             (FunApp (StanLib Minus__ FnPlain AoS)
@@ -22653,9 +22658,9 @@
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -22760,7 +22765,7 @@
     ((begin_loc ((filename mother.stan) (line_num 620) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 620) (col_num 48) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern
           (FunApp (StanLib Plus__ FnPlain AoS)
@@ -22801,7 +22806,7 @@
          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -22831,10 +22836,10 @@
     ((begin_loc ((filename mother.stan) (line_num 625) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 625) (col_num 39) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block TransformedParameters)
      (out_trans
@@ -22844,16 +22849,16 @@
     ((begin_loc ((filename mother.stan) (line_num 626) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 626) (col_num 45) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray SReal
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS (SReal AoS)
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray SReal
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS (SReal AoS)
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -22878,12 +22883,12 @@
     ((begin_loc ((filename mother.stan) (line_num 628) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 628) (col_num 31) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -22892,18 +22897,18 @@
     ((begin_loc ((filename mother.stan) (line_num 629) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 629) (col_num 37) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -22924,12 +22929,12 @@
     ((begin_loc ((filename mother.stan) (line_num 631) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 631) (col_num 39) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -22938,18 +22943,18 @@
     ((begin_loc ((filename mother.stan) (line_num 632) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 632) (col_num 45) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -22972,16 +22977,16 @@
     ((begin_loc ((filename mother.stan) (line_num 634) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 634) (col_num 55) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (SMatrix AoS
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (SMatrix AoS
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23011,7 +23016,7 @@
     ((begin_loc ((filename mother.stan) (line_num 636) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 636) (col_num 36) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern
           (FunApp (StanLib Minus__ FnPlain AoS)
@@ -23021,7 +23026,7 @@
          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -23030,9 +23035,9 @@
     ((begin_loc ((filename mother.stan) (line_num 637) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 637) (col_num 42) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern
             (FunApp (StanLib Minus__ FnPlain AoS)
@@ -23044,9 +23049,9 @@
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23151,7 +23156,7 @@
     ((begin_loc ((filename mother.stan) (line_num 640) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 640) (col_num 49) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern
           (FunApp (StanLib Plus__ FnPlain AoS)
@@ -23192,7 +23197,7 @@
          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23211,26 +23216,26 @@
    (tp_real
     ((begin_loc ((filename mother.stan) (line_num 642) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 642) (col_num 15) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
      (out_block TransformedParameters) (out_trans Identity)))
    (gq_r1
     ((begin_loc ((filename mother.stan) (line_num 733) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 733) (col_num 32) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
      (out_block GeneratedQuantities) (out_trans Identity)))
    (gq_r2
     ((begin_loc ((filename mother.stan) (line_num 734) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 734) (col_num 27) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
      (out_block GeneratedQuantities) (out_trans Identity)))
    (gq_real_1d_ar
     ((begin_loc ((filename mother.stan) (line_num 735) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 735) (col_num 39) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block GeneratedQuantities)
      (out_trans
@@ -23240,16 +23245,16 @@
     ((begin_loc ((filename mother.stan) (line_num 736) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 736) (col_num 45) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray SReal
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS (SReal AoS)
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray SReal
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS (SReal AoS)
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -23274,12 +23279,12 @@
     ((begin_loc ((filename mother.stan) (line_num 738) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 738) (col_num 31) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -23288,18 +23293,18 @@
     ((begin_loc ((filename mother.stan) (line_num 739) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 739) (col_num 37) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23320,12 +23325,12 @@
     ((begin_loc ((filename mother.stan) (line_num 741) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 741) (col_num 39) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -23334,18 +23339,18 @@
     ((begin_loc ((filename mother.stan) (line_num 742) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 742) (col_num 45) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SRowVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23356,16 +23361,16 @@
     ((begin_loc ((filename mother.stan) (line_num 743) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 743) (col_num 55) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (SMatrix AoS
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
         ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (SMatrix AoS
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23395,7 +23400,7 @@
     ((begin_loc ((filename mother.stan) (line_num 745) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 745) (col_num 36) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern
           (FunApp (StanLib Minus__ FnPlain AoS)
@@ -23405,7 +23410,7 @@
          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -23414,9 +23419,9 @@
     ((begin_loc ((filename mother.stan) (line_num 746) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 746) (col_num 42) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern
             (FunApp (StanLib Minus__ FnPlain AoS)
@@ -23428,9 +23433,9 @@
         ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
-        (SArray
+      (SArray AoS
+       (SArray AoS
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23535,7 +23540,7 @@
     ((begin_loc ((filename mother.stan) (line_num 749) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 749) (col_num 49) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern
           (FunApp (StanLib Plus__ FnPlain AoS)
@@ -23576,7 +23581,7 @@
          (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Var K)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23586,23 +23591,23 @@
     ((begin_loc ((filename mother.stan) (line_num 750) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 750) (col_num 35) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SInt
+      (SArray AoS (SInt AoS)
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SInt
+      (SArray AoS (SInt AoS)
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block GeneratedQuantities) (out_trans Identity)))
    (indexing_mat
     ((begin_loc ((filename mother.stan) (line_num 751) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 751) (col_num 37) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23612,13 +23617,13 @@
     ((begin_loc ((filename mother.stan) (line_num 752) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 752) (col_num 33) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23628,13 +23633,13 @@
     ((begin_loc ((filename mother.stan) (line_num 753) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 753) (col_num 33) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23644,13 +23649,13 @@
     ((begin_loc ((filename mother.stan) (line_num 754) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 754) (col_num 33) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23660,13 +23665,13 @@
     ((begin_loc ((filename mother.stan) (line_num 755) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 755) (col_num 34) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23676,13 +23681,13 @@
     ((begin_loc ((filename mother.stan) (line_num 756) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 756) (col_num 34) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 5)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23692,13 +23697,13 @@
     ((begin_loc ((filename mother.stan) (line_num 757) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 757) (col_num 34) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SMatrix AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -23708,12 +23713,12 @@
     ((begin_loc ((filename mother.stan) (line_num 758) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 758) (col_num 34) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SRowVector AoS
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -23722,12 +23727,12 @@
     ((begin_loc ((filename mother.stan) (line_num 759) (col_num 2) (included_from ())))
      (end_loc ((filename mother.stan) (line_num 759) (col_num 30) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
diff --git a/test/integration/good/compiler-optimizations/cpp.expected b/test/integration/good/compiler-optimizations/cpp.expected
index ed015bf8f..c7f34fb4f 100644
--- a/test/integration/good/compiler-optimizations/cpp.expected
+++ b/test/integration/good/compiler-optimizations/cpp.expected
@@ -19,9 +19,6 @@ static constexpr std::array<const char*, 11> locations_array__ =
   " (in 'ad-level-deep-dependence.stan', line 7, column 4 to column 23)"};
 class ad_level_deep_dependence_model final : public model_base_crtp<ad_level_deep_dependence_model> {
  private:
-  double lcm_sym26__;
-  double lcm_sym25__;
-  int lcm_sym24__;
   Eigen::Matrix<double,-1,-1> X_d_data__;
   Eigen::Map<Eigen::Matrix<double,-1,-1>> X_d{nullptr, 0, 0};
  public:
@@ -1982,8 +1979,6 @@ simple_SIR(const T0__& t, const std::vector<T1__>& y,
 }
 class ad_level_failing_model final : public model_base_crtp<ad_level_failing_model> {
  private:
-  double lcm_sym37__;
-  double lcm_sym36__;
   int N_t;
   std::vector<double> t;
   std::vector<double> y0;
@@ -2722,9 +2717,6 @@ static constexpr std::array<const char*, 6> locations_array__ =
   " (in 'ad-levels-deep.stan', line 2, column 4 to column 26)"};
 class ad_levels_deep_model final : public model_base_crtp<ad_levels_deep_model> {
  private:
-  double lcm_sym14__;
-  double lcm_sym13__;
-  int lcm_sym12__;
   Eigen::Matrix<double,-1,-1> X_data_data__;
   Eigen::Map<Eigen::Matrix<double,-1,-1>> X_data{nullptr, 0, 0};
  public:
@@ -4874,6 +4866,8 @@ stan::math::profile_map& get_stan_profile_data() {
   return copy_prop_profile_model_namespace::profiles__;
 }
 #endif
+SoA (Line 0) warning: Right hand side of assignment is all AoS: X, lcm_sym7__
+SoA (Line 0) warning: Function on right hand side of assignment is not supported by SoA: X, lcm_sym7__
   $ ../../../../../install/default/bin/stanc --O --print-cpp copy_fail.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -5178,19 +5172,6 @@ prob_uncaptured(const int& nind, const int& n_occasions, const T2__& p_arg__,
 }
 class copy_fail_model final : public model_base_crtp<copy_fail_model> {
  private:
-  int lcm_sym171__;
-  int lcm_sym170__;
-  int lcm_sym169__;
-  int lcm_sym168__;
-  int lcm_sym167__;
-  int lcm_sym166__;
-  int lcm_sym165__;
-  int lcm_sym164__;
-  int lcm_sym163__;
-  int lcm_sym162__;
-  int lcm_sym161__;
-  int lcm_sym160__;
-  int lcm_sym159__;
   int nind;
   int n_occasions;
   std::vector<std::vector<int>> y;
@@ -6909,6 +6890,38 @@ stan::math::profile_map& get_stan_profile_data() {
   return copy_fail_model_namespace::profiles__;
 }
 #endif
+SoA (Line 79) warning: Accessed by element in a for loop: phi
+SoA (Line 80) warning: Accessed by element in a for loop: p
+SoA (Line 83) warning: Accessed by element in a for loop: phi
+SoA (Line 84) warning: Accessed by element in a for loop: p
+SoA (Line 0) warning: Accessed by element in a for loop: phi
+SoA (Line 80) warning: Accessed by element in a for loop: p
+SoA (Line 79) warning: Accessed by element in a for loop: phi
+SoA (Line 80) warning: Accessed by element in a for loop: p
+SoA (Line 83) warning: Accessed by element in a for loop: phi
+SoA (Line 0) warning: Accessed by element in a for loop: p
+SoA (Line 83) warning: Accessed by element in a for loop: phi
+SoA (Line 84) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 28) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 100) warning: Accessed by element in a for loop: phi
+SoA (Line 101) warning: Accessed by element in a for loop: p
+SoA (Line 100) warning: Accessed by element in a for loop: phi
+SoA (Line 0) warning: Accessed by element in a for loop: p
+SoA (Line 100) warning: Accessed by element in a for loop: phi
+SoA (Line 101) warning: Accessed by element in a for loop: p
+SoA (Line 1) warning: Right hand side contains only AoS expressions: chi
   $ ../../../../../install/default/bin/stanc --O --print-cpp dce-fail.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -6985,10 +6998,6 @@ static constexpr std::array<const char*, 66> locations_array__ =
   " (in 'dce-fail.stan', line 37, column 9 to column 16)"};
 class dce_fail_model final : public model_base_crtp<dce_fail_model> {
  private:
-  double lcm_sym65__;
-  double lcm_sym64__;
-  int lcm_sym63__;
-  int lcm_sym62__;
   int N;
   int n_age;
   int n_edu;
@@ -8439,6 +8448,8 @@ stan::math::profile_map& get_stan_profile_data() {
   return dce_fail_model_namespace::profiles__;
 }
 #endif
+SoA (Line 60) warning: Accessed by element in a for loop: b_state_hat
+SoA (Line 68) warning: Accessed by element in a for loop: p
   $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-experiment.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -8458,7 +8469,6 @@ static constexpr std::array<const char*, 9> locations_array__ =
   " (in 'expr-prop-experiment.stan', line 12, column 2 to column 23)"};
 class expr_prop_experiment_model final : public model_base_crtp<expr_prop_experiment_model> {
  private:
-  double lcm_sym4__;
   int j;
   double z;
   double x;
@@ -8789,8 +8799,6 @@ static constexpr std::array<const char*, 8> locations_array__ =
   " (in 'expr-prop-experiment2.stan', line 12, column 2 to column 23)"};
 class expr_prop_experiment2_model final : public model_base_crtp<expr_prop_experiment2_model> {
  private:
-  double lcm_sym5__;
-  double lcm_sym4__;
   int j;
   double z;
   double y;
@@ -9122,10 +9130,6 @@ static constexpr std::array<const char*, 12> locations_array__ =
   " (in 'expr-prop-fail.stan', line 3, column 2 to column 14)"};
 class expr_prop_fail_model final : public model_base_crtp<expr_prop_fail_model> {
  private:
-  double lcm_sym21__;
-  double lcm_sym20__;
-  int lcm_sym19__;
-  int lcm_sym18__;
   int N;
   Eigen::Matrix<double,-1,1> y_data__;
   Eigen::Map<Eigen::Matrix<double,-1,1>> y{nullptr, 0};
@@ -9688,6 +9692,7 @@ stan::math::profile_map& get_stan_profile_data() {
   return expr_prop_fail_model_namespace::profiles__;
 }
 #endif
+SoA (Line 16) warning: Accessed by element in a for loop: mu
   $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail2.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -10204,14 +10209,6 @@ static constexpr std::array<const char*, 52> locations_array__ =
   " (in 'expr-prop-fail3.stan', line 32, column 9 to column 10)"};
 class expr_prop_fail3_model final : public model_base_crtp<expr_prop_fail3_model> {
  private:
-  double lcm_sym51__;
-  double lcm_sym50__;
-  double lcm_sym49__;
-  double lcm_sym48__;
-  double lcm_sym47__;
-  double lcm_sym46__;
-  int lcm_sym45__;
-  int lcm_sym44__;
   int N;
   int n_age;
   int n_age_edu;
@@ -11604,6 +11601,11 @@ stan::math::profile_map& get_stan_profile_data() {
   return expr_prop_fail3_model_namespace::profiles__;
 }
 #endif
+SoA (Line 38) warning: Accessed by element in a for loop: y_hat
+SoA (Line 38) warning: Accessed by element in a for loop: beta
+SoA (Line 38) warning: Accessed by element in a for loop: beta
+SoA (Line 38) warning: Accessed by element in a for loop: beta
+SoA (Line 38) warning: Accessed by element in a for loop: beta
   $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail4.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -11657,12 +11659,6 @@ static constexpr std::array<const char*, 43> locations_array__ =
   " (in 'expr-prop-fail4.stan', line 35, column 8 to column 9)"};
 class expr_prop_fail4_model final : public model_base_crtp<expr_prop_fail4_model> {
  private:
-  double lcm_sym37__;
-  double lcm_sym36__;
-  Eigen::Matrix<double,-1,1> lcm_sym35___data__;
-  int lcm_sym34__;
-  int lcm_sym33__;
-  int lcm_sym32__;
   int N;
   int N_edges;
   std::vector<int> node1;
@@ -11670,7 +11666,6 @@ class expr_prop_fail4_model final : public model_base_crtp<expr_prop_fail4_model
   Eigen::Matrix<double,-1,1> E_data__;
   Eigen::Matrix<double,-1,1> log_E_data__;
   int phi_std_raw_1dim__;
-  Eigen::Map<Eigen::Matrix<double,-1,1>> lcm_sym35__{nullptr, 0};
   Eigen::Map<Eigen::Matrix<double,-1,1>> E{nullptr, 0};
   Eigen::Map<Eigen::Matrix<double,-1,1>> log_E{nullptr, 0};
  public:
@@ -12741,16 +12736,6 @@ prob_uncaptured(const int& nind, const int& n_occasions, const T2__& p_arg__,
 }
 class expr_prop_fail5_model final : public model_base_crtp<expr_prop_fail5_model> {
  private:
-  int lcm_sym168__;
-  int lcm_sym167__;
-  int lcm_sym166__;
-  int lcm_sym165__;
-  int lcm_sym164__;
-  int lcm_sym163__;
-  int lcm_sym162__;
-  int lcm_sym161__;
-  int lcm_sym160__;
-  int lcm_sym159__;
   int nind;
   int n_occasions;
   std::vector<std::vector<int>> y;
@@ -14455,6 +14440,38 @@ stan::math::profile_map& get_stan_profile_data() {
   return expr_prop_fail5_model_namespace::profiles__;
 }
 #endif
+SoA (Line 85) warning: Accessed by element in a for loop: phi
+SoA (Line 86) warning: Accessed by element in a for loop: p
+SoA (Line 89) warning: Accessed by element in a for loop: phi
+SoA (Line 90) warning: Accessed by element in a for loop: p
+SoA (Line 0) warning: Accessed by element in a for loop: phi
+SoA (Line 86) warning: Accessed by element in a for loop: p
+SoA (Line 85) warning: Accessed by element in a for loop: phi
+SoA (Line 86) warning: Accessed by element in a for loop: p
+SoA (Line 0) warning: Accessed by element in a for loop: phi
+SoA (Line 0) warning: Accessed by element in a for loop: p
+SoA (Line 89) warning: Accessed by element in a for loop: phi
+SoA (Line 90) warning: Accessed by element in a for loop: p
+SoA (Line 44) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 44) warning: Accessed by element in a for loop: phi
+SoA (Line 44) warning: Accessed by element in a for loop: p
+SoA (Line 44) warning: Accessed by element in a for loop: phi
+SoA (Line 28) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 44) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 44) warning: Accessed by element in a for loop: phi
+SoA (Line 44) warning: Accessed by element in a for loop: p
+SoA (Line 44) warning: Accessed by element in a for loop: phi
+SoA (Line 44) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 44) warning: Accessed by element in a for loop: phi
+SoA (Line 44) warning: Accessed by element in a for loop: p
+SoA (Line 44) warning: Accessed by element in a for loop: phi
+SoA (Line 110) warning: Accessed by element in a for loop: phi
+SoA (Line 111) warning: Accessed by element in a for loop: p
+SoA (Line 110) warning: Accessed by element in a for loop: phi
+SoA (Line 0) warning: Accessed by element in a for loop: p
+SoA (Line 110) warning: Accessed by element in a for loop: phi
+SoA (Line 111) warning: Accessed by element in a for loop: p
+SoA (Line 1) warning: Right hand side contains only AoS expressions: chi
   $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail6.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -15401,16 +15418,6 @@ js_super_lp(const std::vector<std::vector<int>>& y, const std::vector<int>&
 }
 class expr_prop_fail6_model final : public model_base_crtp<expr_prop_fail6_model> {
  private:
-  int lcm_sym346__;
-  int lcm_sym345__;
-  int lcm_sym344__;
-  int lcm_sym343__;
-  int lcm_sym342__;
-  int lcm_sym341__;
-  int lcm_sym340__;
-  int lcm_sym339__;
-  int lcm_sym338__;
-  int lcm_sym337__;
   int M;
   int n_occasions;
   std::vector<std::vector<int>> y;
@@ -18573,6 +18580,62 @@ stan::math::profile_map& get_stan_profile_data() {
   return expr_prop_fail6_model_namespace::profiles__;
 }
 #endif
+SoA (Line 191) warning: Accessed by element in a for loop: nu
+SoA (Line 61) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym17__
+SoA (Line 61) warning: Accessed by element in a for loop: lcm_sym252__
+SoA (Line 54) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym17__
+SoA (Line 61) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym17__
+SoA (Line 61) warning: Accessed by element in a for loop: lcm_sym252__
+SoA (Line 61) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym17__
+SoA (Line 61) warning: Accessed by element in a for loop: lcm_sym252__
+SoA (Line 0) warning: Right hand side of assignment is all AoS: lcm_sym201__, nu
+SoA (Line 0) warning: Right hand side of assignment is all AoS: lcm_sym203__, p
+SoA (Line 137) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 137) warning: Accessed by element in a for loop: nu
+SoA (Line 137) warning: Accessed by element in a for loop: p
+SoA (Line 0) warning: Function prod is not supported: lcm_sym252__
+SoA (Line 112) warning: Function prod is not supported: lcm_sym252__
+SoA (Line 112) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 112) warning: Accessed by element in a for loop: nu
+SoA (Line 112) warning: Function prod is not supported: lcm_sym252__
+SoA (Line 112) warning: Accessed by element in a for loop: p
+SoA (Line 120) warning: Accessed by element in a for loop: lcm_sym252__
+SoA (Line 121) warning: Accessed by element in a for loop: p
+SoA (Line 0) warning: Right hand side of assignment is all AoS: lcm_sym202__, p
+SoA (Line 131) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 131) warning: Accessed by element in a for loop: nu
+SoA (Line 131) warning: Accessed by element in a for loop: p
+SoA (Line 137) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 137) warning: Accessed by element in a for loop: nu
+SoA (Line 137) warning: Accessed by element in a for loop: p
+SoA (Line 137) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 137) warning: Accessed by element in a for loop: nu
+SoA (Line 137) warning: Accessed by element in a for loop: p
+SoA (Line 139) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 0) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 0) warning: Accessed by element in a for loop: nu
+SoA (Line 0) warning: Function prod is not supported: lcm_sym252__
+SoA (Line 0) warning: Accessed by element in a for loop: p
+SoA (Line 112) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 112) warning: Accessed by element in a for loop: nu
+SoA (Line 112) warning: Function prod is not supported: lcm_sym252__
+SoA (Line 112) warning: Accessed by element in a for loop: p
+SoA (Line 112) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 112) warning: Accessed by element in a for loop: nu
+SoA (Line 112) warning: Function prod is not supported: lcm_sym252__
+SoA (Line 112) warning: Accessed by element in a for loop: p
+SoA (Line 115) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 115) warning: Accessed by element in a for loop: nu
+SoA (Line 115) warning: Accessed by element in a for loop: p
+SoA (Line 96) warning: Accessed by element in a for loop: nu
+SoA (Line 96) warning: Accessed by element in a for loop: p
+SoA (Line 120) warning: Accessed by element in a for loop: lcm_sym252__
+SoA (Line 0) warning: Accessed by element in a for loop: p
+SoA (Line 120) warning: Accessed by element in a for loop: lcm_sym252__
+SoA (Line 121) warning: Accessed by element in a for loop: p
+SoA (Line 1) warning: Right hand side contains only AoS expressions: phi
+SoA (Line 1) warning: Right hand side contains only AoS expressions: b
+SoA (Line 1) warning: Right hand side contains only AoS expressions: chi
   $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail7.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -18620,16 +18683,6 @@ static constexpr std::array<const char*, 37> locations_array__ =
   " (in 'expr-prop-fail7.stan', line 40, column 18 to column 19)"};
 class expr_prop_fail7_model final : public model_base_crtp<expr_prop_fail7_model> {
  private:
-  int lcm_sym68__;
-  int lcm_sym67__;
-  double lcm_sym66__;
-  double lcm_sym65__;
-  double lcm_sym64__;
-  double lcm_sym63__;
-  int lcm_sym62__;
-  int lcm_sym61__;
-  int lcm_sym60__;
-  int lcm_sym59__;
   int K;
   int I;
   int J;
@@ -19847,10 +19900,6 @@ static constexpr std::array<const char*, 25> locations_array__ =
   " (in 'expr-prop-fail8.stan', line 22, column 9 to column 10)"};
 class expr_prop_fail8_model final : public model_base_crtp<expr_prop_fail8_model> {
  private:
-  double lcm_sym20__;
-  double lcm_sym19__;
-  int lcm_sym18__;
-  int lcm_sym17__;
   int N;
   int N_edges;
   std::vector<int> node1;
@@ -20852,19 +20901,6 @@ prob_uncaptured(const int& nind, const int& n_occasions, const T2__& p_arg__,
 }
 class fails_test_model final : public model_base_crtp<fails_test_model> {
  private:
-  int lcm_sym171__;
-  int lcm_sym170__;
-  int lcm_sym169__;
-  int lcm_sym168__;
-  int lcm_sym167__;
-  int lcm_sym166__;
-  int lcm_sym165__;
-  int lcm_sym164__;
-  int lcm_sym163__;
-  int lcm_sym162__;
-  int lcm_sym161__;
-  int lcm_sym160__;
-  int lcm_sym159__;
   int nind;
   int n_occasions;
   std::vector<std::vector<int>> y;
@@ -22583,6 +22619,38 @@ stan::math::profile_map& get_stan_profile_data() {
   return fails_test_model_namespace::profiles__;
 }
 #endif
+SoA (Line 79) warning: Accessed by element in a for loop: phi
+SoA (Line 80) warning: Accessed by element in a for loop: p
+SoA (Line 83) warning: Accessed by element in a for loop: phi
+SoA (Line 84) warning: Accessed by element in a for loop: p
+SoA (Line 0) warning: Accessed by element in a for loop: phi
+SoA (Line 80) warning: Accessed by element in a for loop: p
+SoA (Line 79) warning: Accessed by element in a for loop: phi
+SoA (Line 80) warning: Accessed by element in a for loop: p
+SoA (Line 83) warning: Accessed by element in a for loop: phi
+SoA (Line 0) warning: Accessed by element in a for loop: p
+SoA (Line 83) warning: Accessed by element in a for loop: phi
+SoA (Line 84) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 28) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 100) warning: Accessed by element in a for loop: phi
+SoA (Line 101) warning: Accessed by element in a for loop: p
+SoA (Line 100) warning: Accessed by element in a for loop: phi
+SoA (Line 0) warning: Accessed by element in a for loop: p
+SoA (Line 100) warning: Accessed by element in a for loop: phi
+SoA (Line 101) warning: Accessed by element in a for loop: p
+SoA (Line 1) warning: Right hand side contains only AoS expressions: chi
   $ ../../../../../install/default/bin/stanc --O --print-cpp function-in-function-inline.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -22653,9 +22721,6 @@ outer_lpdf(const T0__& phi_arg__, std::ostream* pstream__) {
 }
 class function_in_function_inline_model final : public model_base_crtp<function_in_function_inline_model> {
  private:
-  double lcm_sym23__;
-  double lcm_sym22__;
-  int lcm_sym21__;
   Eigen::Matrix<double,-1,1> phi_data__;
   Eigen::Map<Eigen::Matrix<double,-1,1>> phi{nullptr, 0};
  public:
@@ -25302,11 +25367,9 @@ foo(const int& N, const int& M, std::ostream* pstream__) {
 }
 class inline_tdata_model final : public model_base_crtp<inline_tdata_model> {
  private:
-  Eigen::Matrix<double,-1,-1> lcm_sym6___data__;
   int N;
   int M;
   Eigen::Matrix<double,-1,-1> bar_data__;
-  Eigen::Map<Eigen::Matrix<double,-1,-1>> lcm_sym6__{nullptr, 0, 0};
   Eigen::Map<Eigen::Matrix<double,-1,-1>> bar{nullptr, 0, 0};
  public:
   ~inline_tdata_model() {}
@@ -27117,16 +27180,6 @@ seq_cprob(const T0__& gamma_arg__, std::ostream* pstream__) {
 }
 class inlining_fail2_model final : public model_base_crtp<inlining_fail2_model> {
  private:
-  int lcm_sym357__;
-  int lcm_sym356__;
-  int lcm_sym355__;
-  int lcm_sym354__;
-  int lcm_sym353__;
-  int lcm_sym352__;
-  int lcm_sym351__;
-  int lcm_sym350__;
-  int lcm_sym349__;
-  int lcm_sym348__;
   int M;
   int n_occasions;
   std::vector<std::vector<int>> y;
@@ -30226,6 +30279,55 @@ stan::math::profile_map& get_stan_profile_data() {
   return inlining_fail2_model_namespace::profiles__;
 }
 #endif
+SoA (Line 191) warning: Accessed by element in a for loop: phi
+SoA (Line 0) warning: Accessed by element in a for loop: phi
+SoA (Line 191) warning: Accessed by element in a for loop: phi
+SoA (Line 61) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym23__
+SoA (Line 61) warning: Accessed by element in a for loop: phi
+SoA (Line 61) warning: Accessed by element in a for loop: phi
+SoA (Line 54) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym23__
+SoA (Line 61) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym23__
+SoA (Line 61) warning: Accessed by element in a for loop: phi
+SoA (Line 61) warning: Accessed by element in a for loop: phi
+SoA (Line 61) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym23__
+SoA (Line 61) warning: Accessed by element in a for loop: phi
+SoA (Line 61) warning: Accessed by element in a for loop: phi
+SoA (Line 0) warning: Right hand side of assignment is all AoS: lcm_sym223__, lcm_sym269__
+SoA (Line 131) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 131) warning: Accessed by element in a for loop: lcm_sym269__
+SoA (Line 0) warning: Function prod is not supported: phi
+SoA (Line 106) warning: Function prod is not supported: phi
+SoA (Line 106) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 106) warning: Function prod is not supported: phi
+SoA (Line 106) warning: Accessed by element in a for loop: lcm_sym269__
+SoA (Line 114) warning: Accessed by element in a for loop: phi
+SoA (Line 115) warning: Accessed by element in a for loop: lcm_sym269__
+SoA (Line 0) warning: Right hand side of assignment is all AoS: lcm_sym222__, lcm_sym269__
+SoA (Line 125) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 125) warning: Accessed by element in a for loop: lcm_sym269__
+SoA (Line 131) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 131) warning: Accessed by element in a for loop: lcm_sym269__
+SoA (Line 131) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 131) warning: Accessed by element in a for loop: lcm_sym269__
+SoA (Line 133) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 0) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 0) warning: Function prod is not supported: phi
+SoA (Line 0) warning: Accessed by element in a for loop: lcm_sym269__
+SoA (Line 106) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 106) warning: Function prod is not supported: phi
+SoA (Line 106) warning: Accessed by element in a for loop: lcm_sym269__
+SoA (Line 106) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 106) warning: Function prod is not supported: phi
+SoA (Line 106) warning: Accessed by element in a for loop: lcm_sym269__
+SoA (Line 109) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 109) warning: Accessed by element in a for loop: lcm_sym269__
+SoA (Line 91) warning: Accessed by element in a for loop: lcm_sym269__
+SoA (Line 114) warning: Accessed by element in a for loop: phi
+SoA (Line 0) warning: Accessed by element in a for loop: lcm_sym269__
+SoA (Line 114) warning: Accessed by element in a for loop: phi
+SoA (Line 115) warning: Accessed by element in a for loop: lcm_sym269__
+SoA (Line 1) warning: Right hand side contains only AoS expressions: p
+SoA (Line 1) warning: Right hand side contains only AoS expressions: chi
   $ ../../../../../install/default/bin/stanc --O --print-cpp lcm-experiment.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -30243,8 +30345,6 @@ static constexpr std::array<const char*, 7> locations_array__ =
   " (in 'lcm-experiment.stan', line 11, column 2 to column 38)"};
 class lcm_experiment_model final : public model_base_crtp<lcm_experiment_model> {
  private:
-  double lcm_sym4__;
-  double lcm_sym3__;
   int j;
   double z;
   double x;
@@ -31606,16 +31706,6 @@ prob_uncaptured(const int& nind, const int& n_occasions, const T2__& p_arg__,
 }
 class lcm_fails2_model final : public model_base_crtp<lcm_fails2_model> {
  private:
-  int lcm_sym152__;
-  int lcm_sym151__;
-  int lcm_sym150__;
-  int lcm_sym149__;
-  int lcm_sym148__;
-  int lcm_sym147__;
-  int lcm_sym146__;
-  int lcm_sym145__;
-  int lcm_sym144__;
-  int lcm_sym143__;
   int nind;
   int n_occasions;
   std::vector<std::vector<int>> y;
@@ -33172,6 +33262,38 @@ stan::math::profile_map& get_stan_profile_data() {
   return lcm_fails2_model_namespace::profiles__;
 }
 #endif
+SoA (Line 77) warning: Accessed by element in a for loop: phi
+SoA (Line 78) warning: Accessed by element in a for loop: p
+SoA (Line 81) warning: Accessed by element in a for loop: phi
+SoA (Line 82) warning: Accessed by element in a for loop: p
+SoA (Line 0) warning: Accessed by element in a for loop: phi
+SoA (Line 78) warning: Accessed by element in a for loop: p
+SoA (Line 77) warning: Accessed by element in a for loop: phi
+SoA (Line 78) warning: Accessed by element in a for loop: p
+SoA (Line 81) warning: Accessed by element in a for loop: phi
+SoA (Line 0) warning: Accessed by element in a for loop: p
+SoA (Line 81) warning: Accessed by element in a for loop: phi
+SoA (Line 82) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 28) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 98) warning: Accessed by element in a for loop: phi
+SoA (Line 99) warning: Accessed by element in a for loop: p
+SoA (Line 98) warning: Accessed by element in a for loop: phi
+SoA (Line 0) warning: Accessed by element in a for loop: p
+SoA (Line 98) warning: Accessed by element in a for loop: phi
+SoA (Line 99) warning: Accessed by element in a for loop: p
+SoA (Line 1) warning: Right hand side contains only AoS expressions: chi
   $ ../../../../../install/default/bin/stanc --O --print-cpp lupdf-inlining.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -33759,18 +33881,6 @@ static constexpr std::array<const char*, 52> locations_array__ =
   " (in 'off-dce.stan', line 56, column 8 to column 9)"};
 class off_dce_model final : public model_base_crtp<off_dce_model> {
  private:
-  int lcm_sym53__;
-  int lcm_sym52__;
-  int lcm_sym51__;
-  int lcm_sym50__;
-  double lcm_sym49__;
-  double lcm_sym48__;
-  int lcm_sym47__;
-  int lcm_sym46__;
-  int lcm_sym45__;
-  int lcm_sym44__;
-  int lcm_sym43__;
-  int lcm_sym42__;
   int R;
   int T;
   std::vector<std::vector<int>> y;
@@ -34681,6 +34791,13 @@ stan::math::profile_map& get_stan_profile_data() {
   return off_dce_model_namespace::profiles__;
 }
 #endif
+SoA (Line 0) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: lcm_sym25__
+SoA (Line 0) warning: Right hand side of assignment is all AoS: lcm_sym25__, logit_psi
+SoA (Line 0) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: lcm_sym28__
+SoA (Line 0) warning: Right hand side of assignment is all AoS: lcm_sym28__, logit_p
+SoA (Line 49) warning: Accessed by element in a for loop: lcm_sym25__
+SoA (Line 49) warning: Accessed by element in a for loop: lcm_sym25__
+SoA (Line 42) warning: Accessed by element in a for loop: lcm_sym25__
   $ ../../../../../install/default/bin/stanc --O --print-cpp off-small.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -34726,14 +34843,6 @@ static constexpr std::array<const char*, 35> locations_array__ =
   " (in 'off-small.stan', line 22, column 9 to column 10)"};
 class off_small_model final : public model_base_crtp<off_small_model> {
  private:
-  double lcm_sym43__;
-  double lcm_sym42__;
-  double lcm_sym41__;
-  double lcm_sym40__;
-  double lcm_sym39__;
-  double lcm_sym38__;
-  int lcm_sym37__;
-  int lcm_sym36__;
   int J;
   int N;
   std::vector<int> person;
@@ -35682,6 +35791,9 @@ stan::math::profile_map& get_stan_profile_data() {
   return off_small_model_namespace::profiles__;
 }
 #endif
+SoA (Line 29) warning: Accessed by element in a for loop: y_hat
+SoA (Line 1) warning: Right hand side contains only AoS expressions: a1
+SoA (Line 1) warning: Right hand side contains only AoS expressions: a2
   $ ../../../../../install/default/bin/stanc --O --print-cpp optimizations.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -38550,14 +38662,6 @@ static constexpr std::array<const char*, 28> locations_array__ =
   " (in 'partial-eval.stan', line 17, column 9 to column 10)"};
 class partial_eval_model final : public model_base_crtp<partial_eval_model> {
  private:
-  double lcm_sym39__;
-  double lcm_sym38__;
-  double lcm_sym37__;
-  double lcm_sym36__;
-  double lcm_sym35__;
-  double lcm_sym34__;
-  int lcm_sym33__;
-  int lcm_sym32__;
   int N;
   int n_pair;
   std::vector<int> pair;
@@ -39371,6 +39475,8 @@ stan::math::profile_map& get_stan_profile_data() {
   return partial_eval_model_namespace::profiles__;
 }
 #endif
+SoA (Line 20) warning: Accessed by element in a for loop: y_hat
+SoA (Line 20) warning: Accessed by element in a for loop: beta
   $ ../../../../../install/default/bin/stanc --O --print-cpp partial_eval_multiply.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -39392,11 +39498,6 @@ static constexpr std::array<const char*, 11> locations_array__ =
   " (in 'partial_eval_multiply.stan', line 5, column 2 to column 20)"};
 class partial_eval_multiply_model final : public model_base_crtp<partial_eval_multiply_model> {
  private:
-  double lcm_sym18__;
-  double lcm_sym17__;
-  double lcm_sym16__;
-  double lcm_sym15__;
-  int lcm_sym14__;
   Eigen::Matrix<double,-1,-1> m1_data__;
   Eigen::Matrix<double,-1,-1> m4_data__;
   std::vector<int> idx;
@@ -42316,10 +42417,8 @@ static constexpr std::array<const char*, 6> locations_array__ =
   " (in 'partial_eval_zeros.stan', line 6, column 2 to column 11)"};
 class partial_eval_zeros_model final : public model_base_crtp<partial_eval_zeros_model> {
  private:
-  Eigen::Matrix<double,-1,1> lcm_sym3___data__;
   Eigen::Matrix<double,-1,1> v_data__;
   double y;
-  Eigen::Map<Eigen::Matrix<double,-1,1>> lcm_sym3__{nullptr, 0};
   Eigen::Map<Eigen::Matrix<double,-1,1>> v{nullptr, 0};
  public:
   ~partial_eval_zeros_model() {}
@@ -42672,13 +42771,6 @@ static constexpr std::array<const char*, 33> locations_array__ =
   " (in 'stalled1-failure.stan', line 32, column 18 to column 19)"};
 class stalled1_failure_model final : public model_base_crtp<stalled1_failure_model> {
  private:
-  double lcm_sym41__;
-  double lcm_sym40__;
-  double lcm_sym39__;
-  double lcm_sym38__;
-  int lcm_sym37__;
-  int lcm_sym36__;
-  Eigen::Matrix<double,-1,1> lcm_sym35___data__;
   int I;
   std::vector<int> n;
   std::vector<int> N;
@@ -42686,7 +42778,6 @@ class stalled1_failure_model final : public model_base_crtp<stalled1_failure_mod
   Eigen::Matrix<double,-1,1> x2_data__;
   int K;
   Eigen::Matrix<double,-1,1> x1x2_data__;
-  Eigen::Map<Eigen::Matrix<double,-1,1>> lcm_sym35__{nullptr, 0};
   Eigen::Map<Eigen::Matrix<double,-1,1>> x1{nullptr, 0};
   Eigen::Map<Eigen::Matrix<double,-1,1>> x2{nullptr, 0};
   Eigen::Map<Eigen::Matrix<double,-1,1>> x1x2{nullptr, 0};
@@ -43685,7 +43776,6 @@ static constexpr std::array<const char*, 8> locations_array__ =
   " (in 'unenforce-initialize-should-fail.stan', line 2, column 2 to column 60)"};
 class unenforce_initialize_should_fail_model final : public model_base_crtp<unenforce_initialize_should_fail_model> {
  private:
-  std::vector<Eigen::Matrix<double,-1,1>> lcm_sym24__;
   std::vector<Eigen::Matrix<double,-1,1>> inputs;
  public:
   ~unenforce_initialize_should_fail_model() {}
diff --git a/test/integration/good/compiler-optimizations/cppO1.expected b/test/integration/good/compiler-optimizations/cppO1.expected
index 8c97f5dae..554449214 100644
--- a/test/integration/good/compiler-optimizations/cppO1.expected
+++ b/test/integration/good/compiler-optimizations/cppO1.expected
@@ -2303,6 +2303,12 @@ stan::math::profile_map& get_stan_profile_data() {
   return copy_prop_profile_model_namespace::profiles__;
 }
 #endif
+SoA (Line 12) warning: Right hand side of assignment is all AoS: X, vec2
+SoA (Line 12) warning: Function on right hand side of assignment is not supported by SoA: X, vec2
+SoA (Line 20) warning: Right hand side of assignment is all AoS: X, vec4
+SoA (Line 20) warning: Function on right hand side of assignment is not supported by SoA: X, vec4
+SoA (Line 1) warning: Right hand side contains only AoS expressions: vec
+SoA (Line 1) warning: Right hand side contains only AoS expressions: vec3
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp copy_fail.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -3498,6 +3504,18 @@ stan::math::profile_map& get_stan_profile_data() {
   return copy_fail_model_namespace::profiles__;
 }
 #endif
+SoA (Line 79) warning: Accessed by element in a for loop: phi
+SoA (Line 80) warning: Accessed by element in a for loop: p
+SoA (Line 83) warning: Accessed by element in a for loop: phi
+SoA (Line 84) warning: Accessed by element in a for loop: p
+SoA (Line 28) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 100) warning: Accessed by element in a for loop: phi
+SoA (Line 101) warning: Accessed by element in a for loop: p
+SoA (Line 1) warning: Right hand side contains only AoS expressions: inline_prob_uncaptured_return_sym8__
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp dce-fail.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -4754,6 +4772,8 @@ stan::math::profile_map& get_stan_profile_data() {
   return dce_fail_model_namespace::profiles__;
 }
 #endif
+SoA (Line 60) warning: Accessed by element in a for loop: b_state_hat
+SoA (Line 68) warning: Accessed by element in a for loop: p
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp expr-prop-experiment.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -5924,6 +5944,7 @@ stan::math::profile_map& get_stan_profile_data() {
   return expr_prop_fail_model_namespace::profiles__;
 }
 #endif
+SoA (Line 16) warning: Accessed by element in a for loop: mu
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp expr-prop-fail2.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -7553,6 +7574,11 @@ stan::math::profile_map& get_stan_profile_data() {
   return expr_prop_fail3_model_namespace::profiles__;
 }
 #endif
+SoA (Line 38) warning: Accessed by element in a for loop: y_hat
+SoA (Line 38) warning: Accessed by element in a for loop: beta
+SoA (Line 38) warning: Accessed by element in a for loop: beta
+SoA (Line 38) warning: Accessed by element in a for loop: beta
+SoA (Line 38) warning: Accessed by element in a for loop: beta
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp expr-prop-fail4.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -9556,6 +9582,18 @@ stan::math::profile_map& get_stan_profile_data() {
   return expr_prop_fail5_model_namespace::profiles__;
 }
 #endif
+SoA (Line 85) warning: Accessed by element in a for loop: phi
+SoA (Line 86) warning: Accessed by element in a for loop: p
+SoA (Line 89) warning: Accessed by element in a for loop: phi
+SoA (Line 90) warning: Accessed by element in a for loop: p
+SoA (Line 28) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 44) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 44) warning: Accessed by element in a for loop: phi
+SoA (Line 44) warning: Accessed by element in a for loop: p
+SoA (Line 44) warning: Accessed by element in a for loop: phi
+SoA (Line 110) warning: Accessed by element in a for loop: phi
+SoA (Line 111) warning: Accessed by element in a for loop: p
+SoA (Line 1) warning: Right hand side contains only AoS expressions: inline_prob_uncaptured_return_sym8__
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp expr-prop-fail6.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -10777,7 +10815,7 @@ class expr_prop_fail6_model final : public model_base_crtp<expr_prop_fail6_model
       stan::model::assign(b, stan::math::divide(beta, stan::math::sum(beta)),
         "assigning variable b");
       {
-        local_scalar_t__ cum_b;
+        local_scalar_t__ cum_b = DUMMY_VAR__;
         current_statement__ = 21;
         cum_b = stan::model::rvalue(b, "b", stan::model::index_uni(1));
         current_statement__ = 22;
@@ -10894,13 +10932,15 @@ class expr_prop_fail6_model final : public model_base_crtp<expr_prop_fail6_model
         current_statement__ = 82;
         lp_accum__.add(stan::math::gamma_lpdf<propto__>(beta, 1, 1));
         {
-          int inline_js_super_lp_n_ind_sym23__;
+          int inline_js_super_lp_n_ind_sym23__ =
+            std::numeric_limits<int>::min();
           current_statement__ = 83;
           inline_js_super_lp_n_ind_sym23__ = stan::model::rvalue(
                                                stan::math::dims(y),
                                                "dims(y)",
                                                stan::model::index_uni(1));
-          int inline_js_super_lp_n_occasions_sym24__;
+          int inline_js_super_lp_n_occasions_sym24__ =
+            std::numeric_limits<int>::min();
           current_statement__ = 84;
           inline_js_super_lp_n_occasions_sym24__ = stan::model::rvalue(
                                                      stan::math::dims(y),
@@ -11933,6 +11973,35 @@ stan::math::profile_map& get_stan_profile_data() {
   return expr_prop_fail6_model_namespace::profiles__;
 }
 #endif
+SoA (Line 191) warning: Accessed by element in a for loop: nu
+SoA (Line 54) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym17__
+SoA (Line 61) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym17__
+SoA (Line 61) warning: Accessed by element in a for loop: phi
+SoA (Line 84) warning: Right hand side of assignment is all AoS: inline_js_super_lp_qnu_sym25__, nu
+SoA (Line 87) warning: Right hand side of assignment is all AoS: inline_js_super_lp_qp_sym26__, p
+SoA (Line 131) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 131) warning: Accessed by element in a for loop: nu
+SoA (Line 131) warning: Accessed by element in a for loop: p
+SoA (Line 137) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 137) warning: Accessed by element in a for loop: nu
+SoA (Line 137) warning: Accessed by element in a for loop: p
+SoA (Line 139) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 105) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 105) warning: Accessed by element in a for loop: nu
+SoA (Line 105) warning: Function prod is not supported: phi
+SoA (Line 105) warning: Accessed by element in a for loop: p
+SoA (Line 112) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 112) warning: Accessed by element in a for loop: nu
+SoA (Line 112) warning: Function prod is not supported: phi
+SoA (Line 112) warning: Accessed by element in a for loop: p
+SoA (Line 115) warning: Accessed by element in a for loop: inline_js_super_lp_lp_sym27__
+SoA (Line 115) warning: Accessed by element in a for loop: nu
+SoA (Line 115) warning: Accessed by element in a for loop: p
+SoA (Line 96) warning: Accessed by element in a for loop: nu
+SoA (Line 96) warning: Accessed by element in a for loop: p
+SoA (Line 120) warning: Accessed by element in a for loop: phi
+SoA (Line 121) warning: Accessed by element in a for loop: p
+SoA (Line 1) warning: Right hand side contains only AoS expressions: inline_prob_uncaptured_return_sym14__
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp expr-prop-fail7.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -14570,6 +14639,18 @@ stan::math::profile_map& get_stan_profile_data() {
   return fails_test_model_namespace::profiles__;
 }
 #endif
+SoA (Line 79) warning: Accessed by element in a for loop: phi
+SoA (Line 80) warning: Accessed by element in a for loop: p
+SoA (Line 83) warning: Accessed by element in a for loop: phi
+SoA (Line 84) warning: Accessed by element in a for loop: p
+SoA (Line 28) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 100) warning: Accessed by element in a for loop: phi
+SoA (Line 101) warning: Accessed by element in a for loop: p
+SoA (Line 1) warning: Right hand side contains only AoS expressions: inline_prob_uncaptured_return_sym8__
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp function-in-function-inline.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -19037,13 +19118,15 @@ class inlining_fail2_model final : public model_base_crtp<inlining_fail2_model>
         current_statement__ = 83;
         lp_accum__.add(stan::math::normal_lpdf<propto__>(epsilon, 0, sigma));
         {
-          int inline_jolly_seber_lp_n_ind_sym29__;
+          int inline_jolly_seber_lp_n_ind_sym29__ =
+            std::numeric_limits<int>::min();
           current_statement__ = 84;
           inline_jolly_seber_lp_n_ind_sym29__ = stan::model::rvalue(
                                                   stan::math::dims(y),
                                                   "dims(y)",
                                                   stan::model::index_uni(1));
-          int inline_jolly_seber_lp_n_occasions_sym30__;
+          int inline_jolly_seber_lp_n_occasions_sym30__ =
+            std::numeric_limits<int>::min();
           current_statement__ = 85;
           inline_jolly_seber_lp_n_occasions_sym30__ = stan::model::rvalue(
                                                         stan::math::dims(y),
@@ -20058,6 +20141,29 @@ stan::math::profile_map& get_stan_profile_data() {
   return inlining_fail2_model_namespace::profiles__;
 }
 #endif
+SoA (Line 191) warning: Accessed by element in a for loop: phi
+SoA (Line 54) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym23__
+SoA (Line 61) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym23__
+SoA (Line 61) warning: Accessed by element in a for loop: phi
+SoA (Line 61) warning: Accessed by element in a for loop: phi
+SoA (Line 85) warning: Right hand side of assignment is all AoS: inline_jolly_seber_lp_qp_sym32__, p
+SoA (Line 125) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 125) warning: Accessed by element in a for loop: p
+SoA (Line 131) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 131) warning: Accessed by element in a for loop: p
+SoA (Line 133) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 99) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 99) warning: Function prod is not supported: phi
+SoA (Line 99) warning: Accessed by element in a for loop: p
+SoA (Line 106) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 106) warning: Function prod is not supported: phi
+SoA (Line 106) warning: Accessed by element in a for loop: p
+SoA (Line 109) warning: Accessed by element in a for loop: inline_jolly_seber_lp_lp_sym33__
+SoA (Line 109) warning: Accessed by element in a for loop: p
+SoA (Line 91) warning: Accessed by element in a for loop: p
+SoA (Line 114) warning: Accessed by element in a for loop: phi
+SoA (Line 115) warning: Accessed by element in a for loop: p
+SoA (Line 1) warning: Right hand side contains only AoS expressions: inline_prob_uncaptured_return_sym20__
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp lcm-experiment.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -22240,6 +22346,18 @@ stan::math::profile_map& get_stan_profile_data() {
   return lcm_fails2_model_namespace::profiles__;
 }
 #endif
+SoA (Line 77) warning: Accessed by element in a for loop: phi
+SoA (Line 78) warning: Accessed by element in a for loop: p
+SoA (Line 81) warning: Accessed by element in a for loop: phi
+SoA (Line 82) warning: Accessed by element in a for loop: p
+SoA (Line 28) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: inline_prob_uncaptured_chi_sym9__
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 42) warning: Accessed by element in a for loop: p
+SoA (Line 42) warning: Accessed by element in a for loop: phi
+SoA (Line 98) warning: Accessed by element in a for loop: phi
+SoA (Line 99) warning: Accessed by element in a for loop: p
+SoA (Line 1) warning: Right hand side contains only AoS expressions: inline_prob_uncaptured_return_sym8__
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp lupdf-inlining.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -23561,6 +23679,11 @@ stan::math::profile_map& get_stan_profile_data() {
   return off_dce_model_namespace::profiles__;
 }
 #endif
+SoA (Line 30) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: logit_psi
+SoA (Line 31) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: logit_p
+SoA (Line 49) warning: Accessed by element in a for loop: logit_psi
+SoA (Line 49) warning: Accessed by element in a for loop: logit_psi
+SoA (Line 42) warning: Accessed by element in a for loop: logit_psi
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp off-small.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -24427,6 +24550,7 @@ stan::math::profile_map& get_stan_profile_data() {
   return off_small_model_namespace::profiles__;
 }
 #endif
+SoA (Line 29) warning: Accessed by element in a for loop: y_hat
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp optimizations.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -27479,6 +27603,8 @@ stan::math::profile_map& get_stan_profile_data() {
   return partial_eval_model_namespace::profiles__;
 }
 #endif
+SoA (Line 20) warning: Accessed by element in a for loop: y_hat
+SoA (Line 20) warning: Accessed by element in a for loop: beta
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp partial_eval_multiply.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -29495,6 +29621,8 @@ stan::math::profile_map& get_stan_profile_data() {
   return unenforce_initialize_should_fail_model_namespace::profiles__;
 }
 #endif
+SoA (Line 8) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: inputs, local
+SoA (Line 11) warning: Accessed by element in a for loop: local
   $ ../../../../../install/default/bin/stanc --O1 --print-cpp unenforce-initialize.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
diff --git a/test/integration/good/compiler-optimizations/mem_patterns/cpp.expected b/test/integration/good/compiler-optimizations/mem_patterns/cpp.expected
index e128fe1ac..d8f16f0a1 100644
--- a/test/integration/good/compiler-optimizations/mem_patterns/cpp.expected
+++ b/test/integration/good/compiler-optimizations/mem_patterns/cpp.expected
@@ -779,6 +779,10 @@ stan::math::profile_map& get_stan_profile_data() {
   return ad_scalar_data_matrix_model_namespace::profiles__;
 }
 #endif
+SoA (Line 13) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: aos_deep
+SoA (Line 17) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: aos_from_data
+SoA (Line 21) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: aos_mat_from_vecs
+SoA (Line 1) warning: Right hand side contains only AoS expressions: aos_mat_rep
   $ ../../../../../../install/default/bin/stanc -fsoa --print-cpp complex-fails.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -4161,6 +4165,7 @@ stan::math::profile_map& get_stan_profile_data() {
   return deep_dependence_model_namespace::profiles__;
 }
 #endif
+SoA (Line 19) warning: Accessed by element in a for loop: X_tp7
   $ ../../../../../../install/default/bin/stanc -fsoa --print-cpp indexing.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -6722,6 +6727,16 @@ stan::math::profile_map& get_stan_profile_data() {
   return indexing_model_namespace::profiles__;
 }
 #endif
+SoA (Line 59) warning: Right hand side of assignment is all AoS: p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 59) warning: Function on right hand side of assignment is not supported by SoA: p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 80) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 81) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 82) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 83) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 101) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 101) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 111) warning: Accessed by element in a for loop: tp_aos_loop_vec_v_uni_idx
+SoA (Line 112) warning: Accessed by element in a for loop: tp_aos_loop_vec_v_multi_uni_idx
   $ ../../../../../../install/default/bin/stanc -fsoa --print-cpp indexing2.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -7907,6 +7922,10 @@ stan::math::profile_map& get_stan_profile_data() {
   return reductions_allowed_model_namespace::profiles__;
 }
 #endif
+SoA (Line 23) warning: Right hand side of assignment is all AoS: aos_x, aos_y, tp_matrix_aos_from_mix
+SoA (Line 24) warning: Used in user defined function:aos_x, aos_y, tp_matrix_aos_from_mix
+SoA (Line 24) warning: Right hand side of assignment is all AoS: aos_x, tp_matrix_from_udf_reduced_soa
+SoA (Line 24) warning: Function on right hand side of assignment is not supported by SoA: aos_x, tp_matrix_from_udf_reduced_soa
   $ ../../../../../../install/default/bin/stanc -fsoa --print-cpp return_types_and_udfs_demotes.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -8585,6 +8604,14 @@ stan::math::profile_map& get_stan_profile_data() {
   return return_types_and_udfs_demotes_model_namespace::profiles__;
 }
 #endif
+SoA (Line 25) warning: Right hand side of assignment is all AoS: udf_input_aos, user_func_aos
+SoA (Line 25) warning: Function on right hand side of assignment is not supported by SoA: udf_input_aos, user_func_aos
+SoA (Line 26) warning: Used in user defined function:udf_input_aos, user_func_aos
+SoA (Line 26) warning: Function on right hand side of assignment is not supported by SoA: empty_user_func_aos
+SoA (Line 27) warning: Used in user defined function:empty_user_func_aos, udf_input_aos, user_func_aos
+SoA (Line 27) warning: Right hand side of assignment is all AoS: inner_empty_user_func_aos, udf_input_aos
+SoA (Line 28) warning: Right hand side of assignment is all AoS: empty_user_func_aos, int_aos_mul_aos
+SoA (Line 29) warning: Right hand side of assignment is all AoS: int_aos_mul_aos, mul_two_aos, user_func_aos
   $ ../../../../../../install/default/bin/stanc -fsoa --print-cpp single_indexing.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -9666,6 +9693,8 @@ stan::math::profile_map& get_stan_profile_data() {
   return tp_reused_model_namespace::profiles__;
 }
 #endif
+SoA (Line 22) warning: Right hand side of assignment is all AoS: aos_x, tp_matrix_aos
+SoA (Line 22) warning: Function on right hand side of assignment is not supported by SoA: aos_x, tp_matrix_aos
   $ ../../../../../../install/default/bin/stanc -fsoa --print-cpp tuple_test.stan
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
@@ -10277,3 +10306,5 @@ stan::math::profile_map& get_stan_profile_data() {
   return tuple_test_model_namespace::profiles__;
 }
 #endif
+SoA (Line 6) warning: Right hand side of assignment is all AoS: x, xx
+SoA (Line 6) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: x, xx
diff --git a/test/integration/good/compiler-optimizations/mem_patterns/cppOpenCL.expected b/test/integration/good/compiler-optimizations/mem_patterns/cppOpenCL.expected
new file mode 100644
index 000000000..d274664cc
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/mem_patterns/cppOpenCL.expected
@@ -0,0 +1,10219 @@
+  $ ../../../../../../install/default/bin/stanc --use-opencl --print-cpp ad_scalar_data_matrix.stan
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace ad_scalar_data_matrix_model_namespace {
+using stan::model::model_base_crtp;
+using namespace stan::math;
+stan::math::profile_map profiles__;
+static constexpr std::array<const char*, 42> locations_array__ =
+  {" (found before start of program)",
+  " (in 'ad_scalar_data_matrix.stan', line 7, column 2 to column 13)",
+  " (in 'ad_scalar_data_matrix.stan', line 8, column 2 to column 13)",
+  " (in 'ad_scalar_data_matrix.stan', line 9, column 2 to column 17)",
+  " (in 'ad_scalar_data_matrix.stan', line 12, column 9 to column 10)",
+  " (in 'ad_scalar_data_matrix.stan', line 12, column 2 to column 58)",
+  " (in 'ad_scalar_data_matrix.stan', line 13, column 9 to column 10)",
+  " (in 'ad_scalar_data_matrix.stan', line 13, column 2 to column 51)",
+  " (in 'ad_scalar_data_matrix.stan', line 14, column 9 to column 10)",
+  " (in 'ad_scalar_data_matrix.stan', line 14, column 2 to column 84)",
+  " (in 'ad_scalar_data_matrix.stan', line 15, column 9 to column 10)",
+  " (in 'ad_scalar_data_matrix.stan', line 15, column 2 to column 65)",
+  " (in 'ad_scalar_data_matrix.stan', line 16, column 9 to column 10)",
+  " (in 'ad_scalar_data_matrix.stan', line 16, column 2 to column 55)",
+  " (in 'ad_scalar_data_matrix.stan', line 17, column 9 to column 10)",
+  " (in 'ad_scalar_data_matrix.stan', line 17, column 2 to column 83)",
+  " (in 'ad_scalar_data_matrix.stan', line 18, column 9 to column 10)",
+  " (in 'ad_scalar_data_matrix.stan', line 18, column 12 to column 13)",
+  " (in 'ad_scalar_data_matrix.stan', line 18, column 2 to column 108)",
+  " (in 'ad_scalar_data_matrix.stan', line 19, column 9 to column 10)",
+  " (in 'ad_scalar_data_matrix.stan', line 19, column 12 to column 13)",
+  " (in 'ad_scalar_data_matrix.stan', line 19, column 2 to column 104)",
+  " (in 'ad_scalar_data_matrix.stan', line 20, column 9 to column 10)",
+  " (in 'ad_scalar_data_matrix.stan', line 20, column 12 to column 13)",
+  " (in 'ad_scalar_data_matrix.stan', line 20, column 2 to column 90)",
+  " (in 'ad_scalar_data_matrix.stan', line 21, column 2 to column 76)",
+  " (in 'ad_scalar_data_matrix.stan', line 22, column 2 to column 40)",
+  " (in 'ad_scalar_data_matrix.stan', line 23, column 2 to column 30)",
+  " (in 'ad_scalar_data_matrix.stan', line 24, column 2 to column 31)",
+  " (in 'ad_scalar_data_matrix.stan', line 25, column 2 to column 30)",
+  " (in 'ad_scalar_data_matrix.stan', line 26, column 2 to column 25)",
+  " (in 'ad_scalar_data_matrix.stan', line 27, column 2 to column 29)",
+  " (in 'ad_scalar_data_matrix.stan', line 28, column 2 to column 33)",
+  " (in 'ad_scalar_data_matrix.stan', line 29, column 2 to column 29)",
+  " (in 'ad_scalar_data_matrix.stan', line 30, column 2 to column 35)",
+  " (in 'ad_scalar_data_matrix.stan', line 2, column 2 to column 8)",
+  " (in 'ad_scalar_data_matrix.stan', line 3, column 9 to column 10)",
+  " (in 'ad_scalar_data_matrix.stan', line 3, column 12 to column 13)",
+  " (in 'ad_scalar_data_matrix.stan', line 3, column 2 to column 22)",
+  " (in 'ad_scalar_data_matrix.stan', line 4, column 9 to column 10)",
+  " (in 'ad_scalar_data_matrix.stan', line 4, column 2 to column 19)",
+  " (in 'ad_scalar_data_matrix.stan', line 9, column 9 to column 10)"};
+class ad_scalar_data_matrix_model final : public model_base_crtp<ad_scalar_data_matrix_model> {
+ private:
+  int N;
+  Eigen::Matrix<double,-1,-1> X_data_data__;
+  Eigen::Matrix<double,-1,1> y_data_data__;
+  stan::math::matrix_cl<int> N_opencl__;
+  stan::math::matrix_cl<double> y_data_opencl__;
+  Eigen::Map<Eigen::Matrix<double,-1,-1>> X_data{nullptr, 0, 0};
+  Eigen::Map<Eigen::Matrix<double,-1,1>> y_data{nullptr, 0};
+ public:
+  ~ad_scalar_data_matrix_model() {}
+  ad_scalar_data_matrix_model(stan::io::var_context& context__, unsigned int
+                              random_seed__ = 0, std::ostream*
+                              pstream__ = nullptr) : model_base_crtp(0) {
+    int current_statement__ = 0;
+    using local_scalar_t__ = double;
+    boost::ecuyer1988 base_rng__ =
+      stan::services::util::create_rng(random_seed__, 0);
+    // suppress unused var warning
+    (void) base_rng__;
+    static constexpr const char* function__ =
+      "ad_scalar_data_matrix_model_namespace::ad_scalar_data_matrix_model";
+    // suppress unused var warning
+    (void) function__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      current_statement__ = 35;
+      context__.validate_dims("data initialization", "N", "int",
+        std::vector<size_t>{});
+      N = std::numeric_limits<int>::min();
+      current_statement__ = 35;
+      N = context__.vals_i("N")[(1 - 1)];
+      current_statement__ = 36;
+      stan::math::validate_non_negative_index("X_data", "N", N);
+      current_statement__ = 37;
+      stan::math::validate_non_negative_index("X_data", "N", N);
+      current_statement__ = 38;
+      context__.validate_dims("data initialization", "X_data", "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(N)});
+      X_data_data__ = Eigen::Matrix<double,-1,-1>::Constant(N, N,
+                        std::numeric_limits<double>::quiet_NaN());
+      new (&X_data)
+        Eigen::Map<Eigen::Matrix<double,-1,-1>>(X_data_data__.data(), N, N);
+      {
+        std::vector<local_scalar_t__> X_data_flat__;
+        current_statement__ = 38;
+        X_data_flat__ = context__.vals_r("X_data");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(X_data, X_data_flat__[(pos__ - 1)],
+              "assigning variable X_data", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      current_statement__ = 39;
+      stan::math::validate_non_negative_index("y_data", "N", N);
+      current_statement__ = 40;
+      context__.validate_dims("data initialization", "y_data", "double",
+        std::vector<size_t>{static_cast<size_t>(N)});
+      y_data_data__ = Eigen::Matrix<double,-1,1>::Constant(N,
+                        std::numeric_limits<double>::quiet_NaN());
+      new (&y_data)
+        Eigen::Map<Eigen::Matrix<double,-1,1>>(y_data_data__.data(), N);
+      {
+        std::vector<local_scalar_t__> y_data_flat__;
+        current_statement__ = 40;
+        y_data_flat__ = context__.vals_r("y_data");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(y_data, y_data_flat__[(pos__ - 1)],
+            "assigning variable y_data", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      current_statement__ = 41;
+      stan::math::validate_non_negative_index("beta", "N", N);
+      current_statement__ = 35;
+      N_opencl__ = std::numeric_limits<int>::min();
+      current_statement__ = 35;
+      N_opencl__ = stan::math::to_matrix_cl(N);
+      current_statement__ = 40;
+      y_data_opencl__ = stan::math::to_matrix_cl(y_data);
+      current_statement__ = 40;
+      y_data_opencl__ = stan::math::to_matrix_cl(y_data);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    num_params_r__ = 1 + 1 + N;
+  }
+  inline std::string model_name() const final {
+    return "ad_scalar_data_matrix_model";
+  }
+  inline std::vector<std::string> model_compile_info() const noexcept {
+    return std::vector<std::string>{"stanc_version = %%NAME%%3 %%VERSION%%",
+             "stancflags = --use-opencl --print-cpp"};
+  }
+  // Base log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_not_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "ad_scalar_data_matrix_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      local_scalar_t__ alpha = DUMMY_VAR__;
+      current_statement__ = 1;
+      alpha = in__.template read<local_scalar_t__>();
+      local_scalar_t__ sigma = DUMMY_VAR__;
+      current_statement__ = 2;
+      sigma = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<local_scalar_t__,-1,1> beta =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 3;
+      beta = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      {
+        current_statement__ = 4;
+        stan::math::validate_non_negative_index("soa_simple", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1> soa_simple =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 5;
+        stan::model::assign(soa_simple,
+          stan::math::add(
+            stan::math::add(alpha, stan::math::rep_vector(0.0, N)), beta),
+          "assigning variable soa_simple");
+        current_statement__ = 6;
+        stan::math::validate_non_negative_index("aos_deep", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1> aos_deep =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 7;
+        stan::model::assign(aos_deep,
+          stan::math::subtract(
+            stan::math::multiply(2,
+              stan::math::Phi(stan::math::divide(y_data, sigma))), 1),
+          "assigning variable aos_deep");
+        current_statement__ = 8;
+        stan::math::validate_non_negative_index("soa_dual_rep", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1> soa_dual_rep =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 9;
+        stan::model::assign(soa_dual_rep,
+          stan::math::add(
+            stan::math::transpose(stan::math::rep_row_vector(0.0, N)),
+            stan::math::rep_vector(sigma, N)),
+          "assigning variable soa_dual_rep");
+        current_statement__ = 10;
+        stan::math::validate_non_negative_index("soa_data_rep", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1> soa_data_rep =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 11;
+        stan::model::assign(soa_data_rep,
+          stan::math::add(stan::math::rep_vector(0.0, N),
+            stan::math::rep_vector(N, N)), "assigning variable soa_data_rep");
+        current_statement__ = 12;
+        stan::math::validate_non_negative_index("soa_mix", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1> soa_mix =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 13;
+        stan::model::assign(soa_mix,
+          stan::math::add(stan::math::Phi(stan::math::divide(y_data, sigma)),
+            soa_simple), "assigning variable soa_mix");
+        current_statement__ = 14;
+        stan::math::validate_non_negative_index("aos_from_data", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1> aos_from_data =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 15;
+        stan::model::assign(aos_from_data,
+          stan::math::subtract(
+            stan::math::subtract(
+              stan::math::add((alpha + (sigma * alpha)), y_data), alpha),
+            (sigma * alpha)), "assigning variable aos_from_data");
+        current_statement__ = 16;
+        stan::math::validate_non_negative_index("soa_mat_rep", "N", N);
+        current_statement__ = 17;
+        stan::math::validate_non_negative_index("soa_mat_rep", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,-1> soa_mat_rep =
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, N, DUMMY_VAR__);
+        current_statement__ = 18;
+        stan::model::assign(soa_mat_rep,
+          stan::math::add(
+            stan::math::transpose(stan::math::rep_matrix(2.0, N, N)),
+            stan::math::rep_matrix(
+              stan::math::sum(stan::math::rep_vector(sigma, N)), N, N)),
+          "assigning variable soa_mat_rep");
+        current_statement__ = 19;
+        stan::math::validate_non_negative_index("soa_mat_rep_vec", "N", N);
+        current_statement__ = 20;
+        stan::math::validate_non_negative_index("soa_mat_rep_vec", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,-1> soa_mat_rep_vec =
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, N, DUMMY_VAR__);
+        current_statement__ = 21;
+        stan::model::assign(soa_mat_rep_vec,
+          stan::math::add(
+            stan::math::transpose(stan::math::rep_matrix(2.0, N, N)),
+            stan::math::rep_matrix(stan::math::rep_vector(sigma, N), N)),
+          "assigning variable soa_mat_rep_vec");
+        current_statement__ = 22;
+        stan::math::validate_non_negative_index("aos_mat_rep", "N", N);
+        current_statement__ = 23;
+        stan::math::validate_non_negative_index("aos_mat_rep", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,-1> aos_mat_rep =
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, N, DUMMY_VAR__);
+        current_statement__ = 24;
+        stan::model::assign(aos_mat_rep,
+          stan::math::add(
+            stan::math::transpose(stan::math::rep_matrix(aos_deep, N)),
+            stan::math::rep_matrix(aos_deep, N)),
+          "assigning variable aos_mat_rep");
+        Eigen::Matrix<local_scalar_t__,-1,-1> aos_mat_from_vecs =
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(2, 2, DUMMY_VAR__);
+        current_statement__ = 25;
+        stan::model::assign(aos_mat_from_vecs,
+          stan::math::to_matrix(
+            std::vector<Eigen::Matrix<local_scalar_t__,1,-1>>{(Eigen::Matrix<local_scalar_t__,1,-1>(2) <<
+                                                                 stan::math::pow(
+                                                                   alpha, 2),
+                                                                sigma).finished(),
+              (Eigen::Matrix<local_scalar_t__,1,-1>(2) << alpha,
+                                                         stan::math::pow(
+                                                           sigma, 2)).finished()}),
+          "assigning variable aos_mat_from_vecs");
+        current_statement__ = 26;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y_data, soa_simple,
+                         aos_deep));
+        current_statement__ = 27;
+        lp_accum__.add(stan::math::sum(soa_dual_rep));
+        current_statement__ = 28;
+        lp_accum__.add(stan::math::sum(aos_from_data));
+        current_statement__ = 29;
+        lp_accum__.add(stan::math::sum(soa_data_rep));
+        current_statement__ = 30;
+        lp_accum__.add(stan::math::sum(soa_mix));
+        current_statement__ = 31;
+        lp_accum__.add(stan::math::sum(soa_mat_rep));
+        current_statement__ = 32;
+        lp_accum__.add(stan::math::sum(soa_mat_rep_vec));
+        current_statement__ = 33;
+        lp_accum__.add(stan::math::sum(aos_mat_rep));
+        current_statement__ = 34;
+        lp_accum__.add(stan::math::sum(aos_mat_from_vecs));
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  // Reverse mode autodiff log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "ad_scalar_data_matrix_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      stan::math::matrix_cl<local_scalar_t__> alpha = DUMMY_VAR__;
+      current_statement__ = 1;
+      alpha = in__.template read<stan::math::matrix_cl<local_scalar_t__>>();
+      stan::math::matrix_cl<local_scalar_t__> sigma = DUMMY_VAR__;
+      current_statement__ = 2;
+      sigma = in__.template read<stan::math::matrix_cl<local_scalar_t__>>();
+      stan::math::var_value<stan::math::matrix_cl<double>> beta =
+        stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,1>::Constant(N,
+                                                               std::numeric_limits<double>::quiet_NaN(
+                                                                 )));
+      current_statement__ = 3;
+      beta = in__.template read<
+               stan::math::var_value<stan::math::matrix_cl<double>>>(N);
+      {
+        current_statement__ = 4;
+        stan::math::validate_non_negative_index("soa_simple", "N", N_opencl__);
+        stan::math::var_value<stan::math::matrix_cl<double>> soa_simple =
+          stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,1>::Constant(N,
+                                                                 std::numeric_limits<double>::quiet_NaN(
+                                                                   )));
+        current_statement__ = 5;
+        stan::model::assign(soa_simple,
+          stan::math::add(
+            stan::math::add(alpha, stan::math::rep_vector(0.0, N_opencl__)),
+            beta), "assigning variable soa_simple");
+        current_statement__ = 6;
+        stan::math::validate_non_negative_index("aos_deep", "N", N_opencl__);
+        Eigen::Matrix<local_scalar_t__,-1,1> aos_deep =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 7;
+        stan::model::assign(aos_deep,
+          stan::math::subtract(
+            stan::math::multiply(2,
+              stan::math::Phi(stan::math::divide(y_data_opencl__, sigma))), 1),
+          "assigning variable aos_deep");
+        current_statement__ = 8;
+        stan::math::validate_non_negative_index("soa_dual_rep", "N",
+          N_opencl__);
+        stan::math::var_value<stan::math::matrix_cl<double>> soa_dual_rep =
+          stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,1>::Constant(N,
+                                                                 std::numeric_limits<double>::quiet_NaN(
+                                                                   )));
+        current_statement__ = 9;
+        stan::model::assign(soa_dual_rep,
+          stan::math::add(
+            stan::math::transpose(stan::math::rep_row_vector(0.0, N_opencl__)),
+            stan::math::rep_vector(sigma, N_opencl__)),
+          "assigning variable soa_dual_rep");
+        current_statement__ = 10;
+        stan::math::validate_non_negative_index("soa_data_rep", "N",
+          N_opencl__);
+        stan::math::var_value<stan::math::matrix_cl<double>> soa_data_rep =
+          stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,1>::Constant(N,
+                                                                 std::numeric_limits<double>::quiet_NaN(
+                                                                   )));
+        current_statement__ = 11;
+        stan::model::assign(soa_data_rep,
+          stan::math::add(stan::math::rep_vector(0.0, N_opencl__),
+            stan::math::rep_vector(N_opencl__, N_opencl__)),
+          "assigning variable soa_data_rep");
+        current_statement__ = 12;
+        stan::math::validate_non_negative_index("soa_mix", "N", N_opencl__);
+        stan::math::var_value<stan::math::matrix_cl<double>> soa_mix =
+          stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,1>::Constant(N,
+                                                                 std::numeric_limits<double>::quiet_NaN(
+                                                                   )));
+        current_statement__ = 13;
+        stan::model::assign(soa_mix,
+          stan::math::add(
+            stan::math::Phi(stan::math::divide(y_data_opencl__, sigma)),
+            soa_simple), "assigning variable soa_mix");
+        current_statement__ = 14;
+        stan::math::validate_non_negative_index("aos_from_data", "N",
+          N_opencl__);
+        Eigen::Matrix<local_scalar_t__,-1,1> aos_from_data =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 15;
+        stan::model::assign(aos_from_data,
+          stan::math::subtract(
+            stan::math::subtract(
+              stan::math::add((alpha + (sigma * alpha)), y_data_opencl__),
+              alpha), (sigma * alpha)), "assigning variable aos_from_data");
+        current_statement__ = 16;
+        stan::math::validate_non_negative_index("soa_mat_rep", "N",
+          N_opencl__);
+        current_statement__ = 17;
+        stan::math::validate_non_negative_index("soa_mat_rep", "N",
+          N_opencl__);
+        stan::math::var_value<stan::math::matrix_cl<double>> soa_mat_rep =
+          stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,-1>::Constant(N,
+                                                                 N,
+                                                                 std::numeric_limits<double>::quiet_NaN(
+                                                                   )));
+        current_statement__ = 18;
+        stan::model::assign(soa_mat_rep,
+          stan::math::add(
+            stan::math::transpose(
+              stan::math::rep_matrix(2.0, N_opencl__, N_opencl__)),
+            stan::math::rep_matrix<
+              stan::math::var_value<stan::math::matrix_cl<double>>>(
+              stan::math::sum(stan::math::rep_vector(sigma, N_opencl__)),
+              N_opencl__, N_opencl__)), "assigning variable soa_mat_rep");
+        current_statement__ = 19;
+        stan::math::validate_non_negative_index("soa_mat_rep_vec", "N",
+          N_opencl__);
+        current_statement__ = 20;
+        stan::math::validate_non_negative_index("soa_mat_rep_vec", "N",
+          N_opencl__);
+        stan::math::var_value<stan::math::matrix_cl<double>>
+          soa_mat_rep_vec =
+          stan::math::var_value<stan::math::matrix_cl<double>>(Eigen::Matrix<double,-1,-1>::Constant(N,
+                                                                 N,
+                                                                 std::numeric_limits<double>::quiet_NaN(
+                                                                   )));
+        current_statement__ = 21;
+        stan::model::assign(soa_mat_rep_vec,
+          stan::math::add(
+            stan::math::transpose(
+              stan::math::rep_matrix(2.0, N_opencl__, N_opencl__)),
+            stan::math::rep_matrix<
+              stan::math::var_value<stan::math::matrix_cl<double>>>(
+              stan::math::rep_vector(sigma, N_opencl__), N_opencl__)),
+          "assigning variable soa_mat_rep_vec");
+        current_statement__ = 22;
+        stan::math::validate_non_negative_index("aos_mat_rep", "N",
+          N_opencl__);
+        current_statement__ = 23;
+        stan::math::validate_non_negative_index("aos_mat_rep", "N",
+          N_opencl__);
+        Eigen::Matrix<local_scalar_t__,-1,-1> aos_mat_rep =
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, N, DUMMY_VAR__);
+        current_statement__ = 24;
+        stan::model::assign(aos_mat_rep,
+          stan::math::add(
+            stan::math::transpose(
+              stan::math::rep_matrix(aos_deep, N_opencl__)),
+            stan::math::rep_matrix(aos_deep, N_opencl__)),
+          "assigning variable aos_mat_rep");
+        Eigen::Matrix<local_scalar_t__,-1,-1> aos_mat_from_vecs =
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(2, 2, DUMMY_VAR__);
+        current_statement__ = 25;
+        stan::model::assign(aos_mat_from_vecs,
+          stan::math::to_matrix(
+            std::vector<Eigen::Matrix<local_scalar_t__,1,-1>>{(Eigen::Matrix<local_scalar_t__,1,-1>(2) <<
+                                                                 stan::math::pow(
+                                                                   alpha, 2),
+                                                                sigma).finished(),
+              (Eigen::Matrix<local_scalar_t__,1,-1>(2) << alpha,
+                                                         stan::math::pow(
+                                                           sigma, 2)).finished()}),
+          "assigning variable aos_mat_from_vecs");
+        current_statement__ = 26;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y_data_opencl__,
+                         soa_simple, aos_deep));
+        current_statement__ = 27;
+        lp_accum__.add(stan::math::sum(soa_dual_rep));
+        current_statement__ = 28;
+        lp_accum__.add(stan::math::sum(aos_from_data));
+        current_statement__ = 29;
+        lp_accum__.add(stan::math::sum(soa_data_rep));
+        current_statement__ = 30;
+        lp_accum__.add(stan::math::sum(soa_mix));
+        current_statement__ = 31;
+        lp_accum__.add(stan::math::sum(soa_mat_rep));
+        current_statement__ = 32;
+        lp_accum__.add(stan::math::sum(soa_mat_rep_vec));
+        current_statement__ = 33;
+        lp_accum__.add(stan::math::sum(aos_mat_rep));
+        current_statement__ = 34;
+        lp_accum__.add(stan::math::sum(aos_mat_from_vecs));
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  template <typename RNG, typename VecR, typename VecI, typename VecVar,
+            stan::require_vector_like_vt<std::is_floating_point,
+            VecR>* = nullptr, stan::require_vector_like_vt<std::is_integral,
+            VecI>* = nullptr, stan::require_vector_vt<std::is_floating_point,
+            VecVar>* = nullptr>
+  inline void
+  write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__,
+                   VecVar& vars__, const bool
+                   emit_transformed_parameters__ = true, const bool
+                   emit_generated_quantities__ = true, std::ostream*
+                   pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    static constexpr bool propto__ = true;
+    // suppress unused var warning
+    (void) propto__;
+    double lp__ = 0.0;
+    // suppress unused var warning
+    (void) lp__;
+    int current_statement__ = 0;
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    constexpr bool jacobian__ = false;
+    // suppress unused var warning
+    (void) jacobian__;
+    static constexpr const char* function__ =
+      "ad_scalar_data_matrix_model_namespace::write_array";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      double alpha = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 1;
+      alpha = in__.template read<local_scalar_t__>();
+      double sigma = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 2;
+      sigma = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<double,-1,1> beta =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 3;
+      beta = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      out__.write(alpha);
+      out__.write(sigma);
+      out__.write(beta);
+      if (stan::math::logical_negation(
+            (stan::math::primitive_value(emit_transformed_parameters__) ||
+            stan::math::primitive_value(emit_generated_quantities__)))) {
+        return ;
+      }
+      if (stan::math::logical_negation(emit_generated_quantities__)) {
+        return ;
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, typename VecI,
+            stan::require_vector_t<VecVar>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr>
+  inline void
+  unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__,
+                         VecVar& vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      local_scalar_t__ alpha = DUMMY_VAR__;
+      current_statement__ = 1;
+      alpha = in__.read<local_scalar_t__>();
+      out__.write(alpha);
+      local_scalar_t__ sigma = DUMMY_VAR__;
+      current_statement__ = 2;
+      sigma = in__.read<local_scalar_t__>();
+      out__.write(sigma);
+      Eigen::Matrix<local_scalar_t__,-1,1> beta =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 3;
+      stan::model::assign(beta,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(N),
+        "assigning variable beta");
+      out__.write(beta);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, stan::require_vector_t<VecVar>* = nullptr>
+  inline void
+  transform_inits_impl(const stan::io::var_context& context__, VecVar&
+                       vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 1;
+      context__.validate_dims("parameter initialization", "alpha", "double",
+        std::vector<size_t>{});
+      current_statement__ = 2;
+      context__.validate_dims("parameter initialization", "sigma", "double",
+        std::vector<size_t>{});
+      current_statement__ = 3;
+      context__.validate_dims("parameter initialization", "beta", "double",
+        std::vector<size_t>{static_cast<size_t>(N)});
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      local_scalar_t__ alpha = DUMMY_VAR__;
+      current_statement__ = 1;
+      alpha = context__.vals_r("alpha")[(1 - 1)];
+      out__.write(alpha);
+      local_scalar_t__ sigma = DUMMY_VAR__;
+      current_statement__ = 2;
+      sigma = context__.vals_r("sigma")[(1 - 1)];
+      out__.write(sigma);
+      Eigen::Matrix<local_scalar_t__,-1,1> beta =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> beta_flat__;
+        current_statement__ = 3;
+        beta_flat__ = context__.vals_r("beta");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(beta, beta_flat__[(pos__ - 1)],
+            "assigning variable beta", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(beta);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  inline void
+  get_param_names(std::vector<std::string>& names__, const bool
+                  emit_transformed_parameters__ = true, const bool
+                  emit_generated_quantities__ = true) const {
+    names__ = std::vector<std::string>{"alpha", "sigma", "beta"};
+    if (emit_transformed_parameters__) {}
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  get_dims(std::vector<std::vector<size_t>>& dimss__, const bool
+           emit_transformed_parameters__ = true, const bool
+           emit_generated_quantities__ = true) const {
+    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{},
+                std::vector<size_t>{},
+                std::vector<size_t>{static_cast<size_t>(N)}};
+    if (emit_transformed_parameters__) {}
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  constrained_param_names(std::vector<std::string>& param_names__, bool
+                          emit_transformed_parameters__ = true, bool
+                          emit_generated_quantities__ = true) const final {
+    param_names__.emplace_back(std::string() + "alpha");
+    param_names__.emplace_back(std::string() + "sigma");
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "beta" + '.' +
+        std::to_string(sym1__));
+    }
+    if (emit_transformed_parameters__) {}
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  unconstrained_param_names(std::vector<std::string>& param_names__, bool
+                            emit_transformed_parameters__ = true, bool
+                            emit_generated_quantities__ = true) const final {
+    param_names__.emplace_back(std::string() + "alpha");
+    param_names__.emplace_back(std::string() + "sigma");
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "beta" + '.' +
+        std::to_string(sym1__));
+    }
+    if (emit_transformed_parameters__) {}
+    if (emit_generated_quantities__) {}
+  }
+  inline std::string get_constrained_sizedtypes() const {
+    return std::string("[{\"name\":\"alpha\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"}]");
+  }
+  inline std::string get_unconstrained_sizedtypes() const {
+    return std::string("[{\"name\":\"alpha\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"}]");
+  }
+  // Begin method overload boilerplate
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, Eigen::Matrix<double,-1,1>& params_r,
+              Eigen::Matrix<double,-1,1>& vars, const bool
+              emit_transformed_parameters = true, const bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = ((1 + 1) + N);
+    const size_t num_transformed = emit_transformed_parameters * (0);
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    std::vector<int> params_i;
+    vars = Eigen::Matrix<double,-1,1>::Constant(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, std::vector<double>& params_r, std::vector<int>&
+              params_i, std::vector<double>& vars, bool
+              emit_transformed_parameters = true, bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = ((1 + 1) + N);
+    const size_t num_transformed = emit_transformed_parameters * (0);
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    vars = std::vector<double>(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(Eigen::Matrix<T_,-1,1>& params_r, std::ostream* pstream = nullptr) const {
+    Eigen::Matrix<int,-1,1> params_i;
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(std::vector<T_>& params_r, std::vector<int>& params_i,
+           std::ostream* pstream = nullptr) const {
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context,
+                  Eigen::Matrix<double,-1,1>& params_r, std::ostream*
+                  pstream = nullptr) const final {
+    std::vector<double> params_r_vec(params_r.size());
+    std::vector<int> params_i;
+    transform_inits(context, params_i, params_r_vec, pstream);
+    params_r = Eigen::Map<Eigen::Matrix<double,-1,1>>(params_r_vec.data(),
+                 params_r_vec.size());
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context, std::vector<int>&
+                  params_i, std::vector<double>& vars, std::ostream*
+                  pstream__ = nullptr) const {
+    vars.resize(num_params_r__);
+    transform_inits_impl(context, vars, pstream__);
+  }
+  inline void
+  unconstrain_array(const std::vector<double>& params_constrained,
+                    std::vector<double>& params_unconstrained, std::ostream*
+                    pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = std::vector<double>(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+  inline void
+  unconstrain_array(const Eigen::Matrix<double,-1,1>& params_constrained,
+                    Eigen::Matrix<double,-1,1>& params_unconstrained,
+                    std::ostream* pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = Eigen::Matrix<double,-1,1>::Constant(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+};
+}
+using stan_model = ad_scalar_data_matrix_model_namespace::ad_scalar_data_matrix_model;
+#ifndef USING_R
+// Boilerplate
+stan::model::model_base&
+new_model(stan::io::var_context& data_context, unsigned int seed,
+          std::ostream* msg_stream) {
+  stan_model* m = new stan_model(data_context, seed, msg_stream);
+  return *m;
+}
+stan::math::profile_map& get_stan_profile_data() {
+  return ad_scalar_data_matrix_model_namespace::profiles__;
+}
+#endif
+OpenCL (Line 13) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: aos_deep
+OpenCL (Line 17) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: aos_from_data
+OpenCL (Line 21) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: aos_mat_from_vecs
+OpenCL (Line 1) warning: Right hand side contains only AoS expressions: aos_mat_rep
+  $ ../../../../../../install/default/bin/stanc --use-opencl --print-cpp complex-fails.stan
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace complex_fails_model_namespace {
+using stan::model::model_base_crtp;
+using namespace stan::math;
+stan::math::profile_map profiles__;
+static constexpr std::array<const char*, 3> locations_array__ =
+  {" (found before start of program)",
+  " (in 'complex-fails.stan', line 2, column 4 to column 23)",
+  " (in 'complex-fails.stan', line 6, column 3 to column 45)"};
+class complex_fails_model final : public model_base_crtp<complex_fails_model> {
+ private:
+  
+ public:
+  ~complex_fails_model() {}
+  complex_fails_model(stan::io::var_context& context__, unsigned int
+                      random_seed__ = 0, std::ostream* pstream__ = nullptr)
+      : model_base_crtp(0) {
+    int current_statement__ = 0;
+    using local_scalar_t__ = double;
+    boost::ecuyer1988 base_rng__ =
+      stan::services::util::create_rng(random_seed__, 0);
+    // suppress unused var warning
+    (void) base_rng__;
+    static constexpr const char* function__ =
+      "complex_fails_model_namespace::complex_fails_model";
+    // suppress unused var warning
+    (void) function__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    num_params_r__ = (10 * 10);
+  }
+  inline std::string model_name() const final {
+    return "complex_fails_model";
+  }
+  inline std::vector<std::string> model_compile_info() const noexcept {
+    return std::vector<std::string>{"stanc_version = %%NAME%%3 %%VERSION%%",
+             "stancflags = --use-opencl --print-cpp"};
+  }
+  // Base log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_not_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "complex_fails_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> A_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      A_p = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10);
+      Eigen::Matrix<std::complex<local_scalar_t__>,-1,-1> A_complex_tp =
+        Eigen::Matrix<std::complex<local_scalar_t__>,-1,-1>::Constant(10, 10,
+          std::complex<local_scalar_t__>(DUMMY_VAR__, DUMMY_VAR__));
+      current_statement__ = 2;
+      stan::model::assign(A_complex_tp, A_p,
+        "assigning variable A_complex_tp");
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  // Reverse mode autodiff log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "complex_fails_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> A_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      A_p = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10);
+      Eigen::Matrix<std::complex<local_scalar_t__>,-1,-1> A_complex_tp =
+        Eigen::Matrix<std::complex<local_scalar_t__>,-1,-1>::Constant(10, 10,
+          std::complex<local_scalar_t__>(DUMMY_VAR__, DUMMY_VAR__));
+      current_statement__ = 2;
+      stan::model::assign(A_complex_tp, A_p,
+        "assigning variable A_complex_tp");
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  template <typename RNG, typename VecR, typename VecI, typename VecVar,
+            stan::require_vector_like_vt<std::is_floating_point,
+            VecR>* = nullptr, stan::require_vector_like_vt<std::is_integral,
+            VecI>* = nullptr, stan::require_vector_vt<std::is_floating_point,
+            VecVar>* = nullptr>
+  inline void
+  write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__,
+                   VecVar& vars__, const bool
+                   emit_transformed_parameters__ = true, const bool
+                   emit_generated_quantities__ = true, std::ostream*
+                   pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    static constexpr bool propto__ = true;
+    // suppress unused var warning
+    (void) propto__;
+    double lp__ = 0.0;
+    // suppress unused var warning
+    (void) lp__;
+    int current_statement__ = 0;
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    constexpr bool jacobian__ = false;
+    // suppress unused var warning
+    (void) jacobian__;
+    static constexpr const char* function__ =
+      "complex_fails_model_namespace::write_array";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<double,-1,-1> A_p =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 1;
+      A_p = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10);
+      Eigen::Matrix<std::complex<double>,-1,-1> A_complex_tp =
+        Eigen::Matrix<std::complex<double>,-1,-1>::Constant(10, 10,
+          std::complex<double>(std::numeric_limits<double>::quiet_NaN(),
+            std::numeric_limits<double>::quiet_NaN()));
+      out__.write(A_p);
+      if (stan::math::logical_negation(
+            (stan::math::primitive_value(emit_transformed_parameters__) ||
+            stan::math::primitive_value(emit_generated_quantities__)))) {
+        return ;
+      }
+      current_statement__ = 2;
+      stan::model::assign(A_complex_tp, A_p,
+        "assigning variable A_complex_tp");
+      if (emit_transformed_parameters__) {
+        out__.write(A_complex_tp);
+      }
+      if (stan::math::logical_negation(emit_generated_quantities__)) {
+        return ;
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, typename VecI,
+            stan::require_vector_t<VecVar>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr>
+  inline void
+  unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__,
+                         VecVar& vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> A_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      stan::model::assign(A_p,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10),
+        "assigning variable A_p");
+      out__.write(A_p);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, stan::require_vector_t<VecVar>* = nullptr>
+  inline void
+  transform_inits_impl(const stan::io::var_context& context__, VecVar&
+                       vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 1;
+      context__.validate_dims("parameter initialization", "A_p", "double",
+        std::vector<size_t>{static_cast<size_t>(10), static_cast<size_t>(10)});
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      Eigen::Matrix<local_scalar_t__,-1,-1> A_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> A_p_flat__;
+        current_statement__ = 1;
+        A_p_flat__ = context__.vals_r("A_p");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+            stan::model::assign(A_p, A_p_flat__[(pos__ - 1)],
+              "assigning variable A_p", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(A_p);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  inline void
+  get_param_names(std::vector<std::string>& names__, const bool
+                  emit_transformed_parameters__ = true, const bool
+                  emit_generated_quantities__ = true) const {
+    names__ = std::vector<std::string>{"A_p"};
+    if (emit_transformed_parameters__) {
+      std::vector<std::string> temp{"A_complex_tp"};
+      names__.reserve(names__.size() + temp.size());
+      names__.insert(names__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  get_dims(std::vector<std::vector<size_t>>& dimss__, const bool
+           emit_transformed_parameters__ = true, const bool
+           emit_generated_quantities__ = true) const {
+    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{static_cast<
+                                                                    size_t>(
+                                                                    10),
+                                                 static_cast<size_t>(10)}};
+    if (emit_transformed_parameters__) {
+      std::vector<std::vector<size_t>>
+        temp{std::vector<size_t>{static_cast<size_t>(10),
+               static_cast<size_t>(10), static_cast<size_t>(2)}};
+      dimss__.reserve(dimss__.size() + temp.size());
+      dimss__.insert(dimss__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  constrained_param_names(std::vector<std::string>& param_names__, bool
+                          emit_transformed_parameters__ = true, bool
+                          emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "A_p" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "A_complex_tp" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__) + '.' +
+            "real");
+          param_names__.emplace_back(std::string() + "A_complex_tp" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__) + '.' +
+            "imag");
+        }
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  unconstrained_param_names(std::vector<std::string>& param_names__, bool
+                            emit_transformed_parameters__ = true, bool
+                            emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "A_p" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "A_complex_tp" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__) + '.' +
+            "real");
+          param_names__.emplace_back(std::string() + "A_complex_tp" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__) + '.' +
+            "imag");
+        }
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline std::string get_constrained_sizedtypes() const {
+    return std::string("[{\"name\":\"A_p\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"A_complex_tp\",\"type\":{\"name\":\"complex_matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  inline std::string get_unconstrained_sizedtypes() const {
+    return std::string("[{\"name\":\"A_p\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"A_complex_tp\",\"type\":{\"name\":\"complex_matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  // Begin method overload boilerplate
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, Eigen::Matrix<double,-1,1>& params_r,
+              Eigen::Matrix<double,-1,1>& vars, const bool
+              emit_transformed_parameters = true, const bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (10 * 10);
+    const size_t num_transformed = emit_transformed_parameters * ((10 * (10 *
+      2)));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    std::vector<int> params_i;
+    vars = Eigen::Matrix<double,-1,1>::Constant(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, std::vector<double>& params_r, std::vector<int>&
+              params_i, std::vector<double>& vars, bool
+              emit_transformed_parameters = true, bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (10 * 10);
+    const size_t num_transformed = emit_transformed_parameters * ((10 * (10 *
+      2)));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    vars = std::vector<double>(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(Eigen::Matrix<T_,-1,1>& params_r, std::ostream* pstream = nullptr) const {
+    Eigen::Matrix<int,-1,1> params_i;
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(std::vector<T_>& params_r, std::vector<int>& params_i,
+           std::ostream* pstream = nullptr) const {
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context,
+                  Eigen::Matrix<double,-1,1>& params_r, std::ostream*
+                  pstream = nullptr) const final {
+    std::vector<double> params_r_vec(params_r.size());
+    std::vector<int> params_i;
+    transform_inits(context, params_i, params_r_vec, pstream);
+    params_r = Eigen::Map<Eigen::Matrix<double,-1,1>>(params_r_vec.data(),
+                 params_r_vec.size());
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context, std::vector<int>&
+                  params_i, std::vector<double>& vars, std::ostream*
+                  pstream__ = nullptr) const {
+    vars.resize(num_params_r__);
+    transform_inits_impl(context, vars, pstream__);
+  }
+  inline void
+  unconstrain_array(const std::vector<double>& params_constrained,
+                    std::vector<double>& params_unconstrained, std::ostream*
+                    pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = std::vector<double>(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+  inline void
+  unconstrain_array(const Eigen::Matrix<double,-1,1>& params_constrained,
+                    Eigen::Matrix<double,-1,1>& params_unconstrained,
+                    std::ostream* pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = Eigen::Matrix<double,-1,1>::Constant(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+};
+}
+using stan_model = complex_fails_model_namespace::complex_fails_model;
+#ifndef USING_R
+// Boilerplate
+stan::model::model_base&
+new_model(stan::io::var_context& data_context, unsigned int seed,
+          std::ostream* msg_stream) {
+  stan_model* m = new stan_model(data_context, seed, msg_stream);
+  return *m;
+}
+stan::math::profile_map& get_stan_profile_data() {
+  return complex_fails_model_namespace::profiles__;
+}
+#endif
+  $ ../../../../../../install/default/bin/stanc --use-opencl --print-cpp constraints.stan
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace constraints_model_namespace {
+using stan::model::model_base_crtp;
+using namespace stan::math;
+stan::math::profile_map profiles__;
+static constexpr std::array<const char*, 92> locations_array__ =
+  {" (found before start of program)",
+  " (in 'constraints.stan', line 20, column 2 to column 66)",
+  " (in 'constraints.stan', line 21, column 2 to column 14)",
+  " (in 'constraints.stan', line 22, column 2 to column 15)",
+  " (in 'constraints.stan', line 23, column 2 to column 15)",
+  " (in 'constraints.stan', line 24, column 2 to column 10)",
+  " (in 'constraints.stan', line 25, column 2 to column 33)",
+  " (in 'constraints.stan', line 26, column 2 to column 23)",
+  " (in 'constraints.stan', line 27, column 2 to column 17)",
+  " (in 'constraints.stan', line 28, column 2 to column 23)",
+  " (in 'constraints.stan', line 29, column 2 to column 35)",
+  " (in 'constraints.stan', line 30, column 2 to column 13)",
+  " (in 'constraints.stan', line 31, column 2 to column 33)",
+  " (in 'constraints.stan', line 32, column 2 to column 66)",
+  " (in 'constraints.stan', line 33, column 2 to column 80)",
+  " (in 'constraints.stan', line 34, column 2 to column 72)",
+  " (in 'constraints.stan', line 35, column 2 to column 26)",
+  " (in 'constraints.stan', line 36, column 2 to column 31)",
+  " (in 'constraints.stan', line 37, column 2 to column 39)",
+  " (in 'constraints.stan', line 38, column 2 to column 34)",
+  " (in 'constraints.stan', line 39, column 2 to column 32)",
+  " (in 'constraints.stan', line 40, column 2 to column 43)",
+  " (in 'constraints.stan', line 41, column 2 to column 45)",
+  " (in 'constraints.stan', line 47, column 2 to column 56)",
+  " (in 'constraints.stan', line 48, column 2 to column 37)",
+  " (in 'constraints.stan', line 50, column 2 to column 46)",
+  " (in 'constraints.stan', line 51, column 2 to column 59)",
+  " (in 'constraints.stan', line 52, column 2 to column 40)",
+  " (in 'constraints.stan', line 54, column 2 to column 17)",
+  " (in 'constraints.stan', line 61, column 2 to column 22)",
+  " (in 'constraints.stan', line 62, column 2 to column 32)",
+  " (in 'constraints.stan', line 67, column 2 to column 70)",
+  " (in 'constraints.stan', line 56, column 2 to column 25)",
+  " (in 'constraints.stan', line 57, column 2 to column 67)",
+  " (in 'constraints.stan', line 58, column 2 to column 46)",
+  " (in 'constraints.stan', line 59, column 2 to column 25)",
+  " (in 'constraints.stan', line 63, column 2 to column 20)",
+  " (in 'constraints.stan', line 64, column 2 to column 44)",
+  " (in 'constraints.stan', line 65, column 2 to column 46)",
+  " (in 'constraints.stan', line 66, column 2 to column 71)",
+  " (in 'constraints.stan', line 72, column 2 to column 34)",
+  " (in 'constraints.stan', line 73, column 2 to column 50)",
+  " (in 'constraints.stan', line 74, column 2 to column 44)",
+  " (in 'constraints.stan', line 75, column 2 to column 54)",
+  " (in 'constraints.stan', line 76, column 2 to column 21)",
+  " (in 'constraints.stan', line 77, column 2 to column 21)",
+  " (in 'constraints.stan', line 78, column 2 to column 34)",
+  " (in 'constraints.stan', line 79, column 2 to column 35)",
+  " (in 'constraints.stan', line 80, column 2 to column 54)",
+  " (in 'constraints.stan', line 81, column 2 to column 43)",
+  " (in 'constraints.stan', line 82, column 2 to column 36)",
+  " (in 'constraints.stan', line 3, column 2 to column 17)",
+  " (in 'constraints.stan', line 4, column 2 to column 17)",
+  " (in 'constraints.stan', line 5, column 9 to column 10)",
+  " (in 'constraints.stan', line 5, column 2 to column 25)",
+  " (in 'constraints.stan', line 6, column 9 to column 10)",
+  " (in 'constraints.stan', line 6, column 2 to column 26)",
+  " (in 'constraints.stan', line 7, column 9 to column 10)",
+  " (in 'constraints.stan', line 7, column 2 to column 22)",
+  " (in 'constraints.stan', line 8, column 9 to column 10)",
+  " (in 'constraints.stan', line 8, column 12 to column 13)",
+  " (in 'constraints.stan', line 8, column 2 to column 21)",
+  " (in 'constraints.stan', line 9, column 2 to column 28)",
+  " (in 'constraints.stan', line 10, column 2 to column 28)",
+  " (in 'constraints.stan', line 11, column 2 to column 19)",
+  " (in 'constraints.stan', line 12, column 2 to column 31)",
+  " (in 'constraints.stan', line 13, column 2 to column 34)",
+  " (in 'constraints.stan', line 14, column 2 to column 33)",
+  " (in 'constraints.stan', line 17, column 2 to column 17)",
+  " (in 'constraints.stan', line 20, column 50 to column 51)",
+  " (in 'constraints.stan', line 21, column 9 to column 10)",
+  " (in 'constraints.stan', line 22, column 9 to column 11)",
+  " (in 'constraints.stan', line 28, column 9 to column 10)",
+  " (in 'constraints.stan', line 29, column 20 to column 21)",
+  " (in 'constraints.stan', line 31, column 19 to column 20)",
+  " (in 'constraints.stan', line 32, column 46 to column 47)",
+  " (in 'constraints.stan', line 33, column 52 to column 53)",
+  " (in 'constraints.stan', line 34, column 52 to column 53)",
+  " (in 'constraints.stan', line 35, column 10 to column 11)",
+  " (in 'constraints.stan', line 36, column 14 to column 15)",
+  " (in 'constraints.stan', line 37, column 19 to column 20)",
+  " (in 'constraints.stan', line 38, column 14 to column 15)",
+  " (in 'constraints.stan', line 39, column 13 to column 14)",
+  " (in 'constraints.stan', line 40, column 22 to column 23)",
+  " (in 'constraints.stan', line 41, column 23 to column 24)",
+  " (in 'constraints.stan', line 50, column 9 to column 10)",
+  " (in 'constraints.stan', line 51, column 9 to column 11)",
+  " (in 'constraints.stan', line 52, column 9 to column 11)",
+  " (in 'constraints.stan', line 54, column 9 to column 11)",
+  " (in 'constraints.stan', line 61, column 9 to column 11)",
+  " (in 'constraints.stan', line 62, column 18 to column 20)",
+  " (in 'constraints.stan', line 67, column 9 to column 11)"};
+class constraints_model final : public model_base_crtp<constraints_model> {
+ private:
+  int N;
+  int K;
+  Eigen::Matrix<double,-1,1> diff_low_mid_data__;
+  Eigen::Matrix<double,-1,1> diff_high_mid_data__;
+  Eigen::Matrix<double,-1,1> mid_price_data__;
+  Eigen::Matrix<double,-1,-1> X_all_data__;
+  double phi_prior_a;
+  double phi_prior_b;
+  double mu_prior_mu;
+  double mu_prior_sigma;
+  double sigma_prior_shape;
+  double sigma_prior_rate;
+  int Nr;
+  Eigen::Map<Eigen::Matrix<double,-1,1>> diff_low_mid{nullptr, 0};
+  Eigen::Map<Eigen::Matrix<double,-1,1>> diff_high_mid{nullptr, 0};
+  Eigen::Map<Eigen::Matrix<double,-1,1>> mid_price{nullptr, 0};
+  Eigen::Map<Eigen::Matrix<double,-1,-1>> X_all{nullptr, 0, 0};
+ public:
+  ~constraints_model() {}
+  constraints_model(stan::io::var_context& context__, unsigned int
+                    random_seed__ = 0, std::ostream* pstream__ = nullptr)
+      : model_base_crtp(0) {
+    int current_statement__ = 0;
+    using local_scalar_t__ = double;
+    boost::ecuyer1988 base_rng__ =
+      stan::services::util::create_rng(random_seed__, 0);
+    // suppress unused var warning
+    (void) base_rng__;
+    static constexpr const char* function__ =
+      "constraints_model_namespace::constraints_model";
+    // suppress unused var warning
+    (void) function__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      current_statement__ = 51;
+      context__.validate_dims("data initialization", "N", "int",
+        std::vector<size_t>{});
+      N = std::numeric_limits<int>::min();
+      current_statement__ = 51;
+      N = context__.vals_i("N")[(1 - 1)];
+      current_statement__ = 51;
+      stan::math::check_greater_or_equal(function__, "N", N, 0);
+      current_statement__ = 52;
+      context__.validate_dims("data initialization", "K", "int",
+        std::vector<size_t>{});
+      K = std::numeric_limits<int>::min();
+      current_statement__ = 52;
+      K = context__.vals_i("K")[(1 - 1)];
+      current_statement__ = 52;
+      stan::math::check_greater_or_equal(function__, "K", K, 1);
+      current_statement__ = 53;
+      stan::math::validate_non_negative_index("diff_low_mid", "N", N);
+      current_statement__ = 54;
+      context__.validate_dims("data initialization", "diff_low_mid",
+        "double", std::vector<size_t>{static_cast<size_t>(N)});
+      diff_low_mid_data__ = Eigen::Matrix<double,-1,1>::Constant(N,
+                              std::numeric_limits<double>::quiet_NaN());
+      new (&diff_low_mid)
+        Eigen::Map<Eigen::Matrix<double,-1,1>>(diff_low_mid_data__.data(), N);
+      {
+        std::vector<local_scalar_t__> diff_low_mid_flat__;
+        current_statement__ = 54;
+        diff_low_mid_flat__ = context__.vals_r("diff_low_mid");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(diff_low_mid, diff_low_mid_flat__[(pos__ - 1)],
+            "assigning variable diff_low_mid", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      current_statement__ = 55;
+      stan::math::validate_non_negative_index("diff_high_mid", "N", N);
+      current_statement__ = 56;
+      context__.validate_dims("data initialization", "diff_high_mid",
+        "double", std::vector<size_t>{static_cast<size_t>(N)});
+      diff_high_mid_data__ = Eigen::Matrix<double,-1,1>::Constant(N,
+                               std::numeric_limits<double>::quiet_NaN());
+      new (&diff_high_mid)
+        Eigen::Map<Eigen::Matrix<double,-1,1>>(diff_high_mid_data__.data(),
+        N);
+      {
+        std::vector<local_scalar_t__> diff_high_mid_flat__;
+        current_statement__ = 56;
+        diff_high_mid_flat__ = context__.vals_r("diff_high_mid");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(diff_high_mid, diff_high_mid_flat__[(pos__ -
+            1)], "assigning variable diff_high_mid",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      current_statement__ = 57;
+      stan::math::validate_non_negative_index("mid_price", "N", N);
+      current_statement__ = 58;
+      context__.validate_dims("data initialization", "mid_price", "double",
+        std::vector<size_t>{static_cast<size_t>(N)});
+      mid_price_data__ = Eigen::Matrix<double,-1,1>::Constant(N,
+                           std::numeric_limits<double>::quiet_NaN());
+      new (&mid_price)
+        Eigen::Map<Eigen::Matrix<double,-1,1>>(mid_price_data__.data(), N);
+      {
+        std::vector<local_scalar_t__> mid_price_flat__;
+        current_statement__ = 58;
+        mid_price_flat__ = context__.vals_r("mid_price");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(mid_price, mid_price_flat__[(pos__ - 1)],
+            "assigning variable mid_price", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      current_statement__ = 59;
+      stan::math::validate_non_negative_index("X_all", "N", N);
+      current_statement__ = 60;
+      stan::math::validate_non_negative_index("X_all", "K", K);
+      current_statement__ = 61;
+      context__.validate_dims("data initialization", "X_all", "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(K)});
+      X_all_data__ = Eigen::Matrix<double,-1,-1>::Constant(N, K,
+                       std::numeric_limits<double>::quiet_NaN());
+      new (&X_all)
+        Eigen::Map<Eigen::Matrix<double,-1,-1>>(X_all_data__.data(), N, K);
+      {
+        std::vector<local_scalar_t__> X_all_flat__;
+        current_statement__ = 61;
+        X_all_flat__ = context__.vals_r("X_all");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= K; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(X_all, X_all_flat__[(pos__ - 1)],
+              "assigning variable X_all", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      current_statement__ = 62;
+      context__.validate_dims("data initialization", "phi_prior_a", "double",
+        std::vector<size_t>{});
+      phi_prior_a = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 62;
+      phi_prior_a = context__.vals_r("phi_prior_a")[(1 - 1)];
+      current_statement__ = 62;
+      stan::math::check_greater_or_equal(function__, "phi_prior_a",
+        phi_prior_a, 0);
+      current_statement__ = 63;
+      context__.validate_dims("data initialization", "phi_prior_b", "double",
+        std::vector<size_t>{});
+      phi_prior_b = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 63;
+      phi_prior_b = context__.vals_r("phi_prior_b")[(1 - 1)];
+      current_statement__ = 63;
+      stan::math::check_greater_or_equal(function__, "phi_prior_b",
+        phi_prior_b, 0);
+      current_statement__ = 64;
+      context__.validate_dims("data initialization", "mu_prior_mu", "double",
+        std::vector<size_t>{});
+      mu_prior_mu = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 64;
+      mu_prior_mu = context__.vals_r("mu_prior_mu")[(1 - 1)];
+      current_statement__ = 65;
+      context__.validate_dims("data initialization", "mu_prior_sigma",
+        "double", std::vector<size_t>{});
+      mu_prior_sigma = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 65;
+      mu_prior_sigma = context__.vals_r("mu_prior_sigma")[(1 - 1)];
+      current_statement__ = 65;
+      stan::math::check_greater_or_equal(function__, "mu_prior_sigma",
+        mu_prior_sigma, 0);
+      current_statement__ = 66;
+      context__.validate_dims("data initialization", "sigma_prior_shape",
+        "double", std::vector<size_t>{});
+      sigma_prior_shape = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 66;
+      sigma_prior_shape = context__.vals_r("sigma_prior_shape")[(1 - 1)];
+      current_statement__ = 66;
+      stan::math::check_greater_or_equal(function__, "sigma_prior_shape",
+        sigma_prior_shape, 0);
+      current_statement__ = 67;
+      context__.validate_dims("data initialization", "sigma_prior_rate",
+        "double", std::vector<size_t>{});
+      sigma_prior_rate = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 67;
+      sigma_prior_rate = context__.vals_r("sigma_prior_rate")[(1 - 1)];
+      current_statement__ = 67;
+      stan::math::check_greater_or_equal(function__, "sigma_prior_rate",
+        sigma_prior_rate, 0);
+      current_statement__ = 68;
+      Nr = std::numeric_limits<int>::min();
+      current_statement__ = 68;
+      Nr = (N - 1);
+      current_statement__ = 69;
+      stan::math::validate_non_negative_index("high_low_est", "N", N);
+      current_statement__ = 70;
+      stan::math::validate_non_negative_index("b", "K", K);
+      current_statement__ = 71;
+      stan::math::validate_non_negative_index("h", "Nr", Nr);
+      current_statement__ = 72;
+      stan::math::validate_non_negative_index("mean_price", "N", N);
+      current_statement__ = 73;
+      stan::math::validate_non_negative_index("sigma_price", "N", N);
+      current_statement__ = 74;
+      stan::math::validate_non_negative_index("upper_test", "N", N);
+      current_statement__ = 75;
+      stan::math::validate_non_negative_index("lower_upper_test", "N", N);
+      current_statement__ = 76;
+      stan::math::validate_non_negative_index("row_vec_lower_upper_test",
+        "N", N);
+      current_statement__ = 77;
+      stan::math::validate_non_negative_index("offset_mult_test", "N", N);
+      current_statement__ = 78;
+      stan::math::validate_non_negative_index("ordered_test", "N", N);
+      current_statement__ = 79;
+      stan::math::validate_unit_vector_index("unit_vec_test", "N", N);
+      current_statement__ = 80;
+      stan::math::validate_non_negative_index("pos_ordered_test", "N", N);
+      current_statement__ = 81;
+      stan::math::validate_non_negative_index("corr_matrix_test", "N", N);
+      current_statement__ = 81;
+      stan::math::validate_non_negative_index("corr_matrix_test", "N", N);
+      current_statement__ = 82;
+      stan::math::validate_non_negative_index("cov_matrix_test", "N", N);
+      current_statement__ = 82;
+      stan::math::validate_non_negative_index("cov_matrix_test", "N", N);
+      current_statement__ = 83;
+      stan::math::validate_non_negative_index("chol_fac_cov_test", "K", K);
+      current_statement__ = 83;
+      stan::math::validate_non_negative_index("chol_fac_cov_test", "K", K);
+      current_statement__ = 83;
+      stan::math::check_greater_or_equal(
+        "cholesky_factor_cov chol_fac_cov_test",
+        "num rows (must be greater or equal to num cols)", K, K);
+      current_statement__ = 84;
+      stan::math::validate_non_negative_index("chol_fac_corr_test", "K", K);
+      current_statement__ = 84;
+      stan::math::validate_non_negative_index("chol_fac_corr_test", "K", K);
+      current_statement__ = 85;
+      stan::math::validate_non_negative_index("prices", "N", N);
+      current_statement__ = 86;
+      stan::math::validate_non_negative_index("prices_diff", "Nr", Nr);
+      current_statement__ = 87;
+      stan::math::validate_non_negative_index("mu", "Nr", Nr);
+      current_statement__ = 88;
+      stan::math::validate_non_negative_index("err", "Nr", Nr);
+      current_statement__ = 89;
+      stan::math::validate_non_negative_index("h_i_mean", "Nr", Nr);
+      current_statement__ = 90;
+      stan::math::validate_non_negative_index("h_i_sigma", "Nr", Nr);
+      current_statement__ = 91;
+      stan::math::validate_non_negative_index("h_sigma", "Nr", Nr);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    num_params_r__ = N + K + Nr + 2 + 1 + 1 + 1 + 1 + N + N + 1 + N + N + N +
+      N + N + N + N + ((N * (N - 1)) / 2) + (N + ((N * (N - 1)) / 2)) + ((((K
+      * (K - 1)) / 2) + K) + ((K - K) * K)) + ((K * (K - 1)) / 2);
+  }
+  inline std::string model_name() const final {
+    return "constraints_model";
+  }
+  inline std::vector<std::string> model_compile_info() const noexcept {
+    return std::vector<std::string>{"stanc_version = %%NAME%%3 %%VERSION%%",
+             "stancflags = --use-opencl --print-cpp"};
+  }
+  // Base log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_not_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "constraints_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,1> high_low_est =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 1;
+      high_low_est = in__.template read_constrain_lub<
+                       Eigen::Matrix<local_scalar_t__,-1,1>,
+                       jacobian__>(diff_low_mid, diff_high_mid, lp__, N);
+      current_statement__ = 1;
+      stan::math::check_matching_dims("constraint", "high_low_est",
+        high_low_est, "lower", diff_low_mid);
+      current_statement__ = 1;
+      stan::math::check_matching_dims("constraint", "high_low_est",
+        high_low_est, "upper", diff_high_mid);
+      Eigen::Matrix<local_scalar_t__,-1,1> b =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(K, DUMMY_VAR__);
+      current_statement__ = 2;
+      b = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(K);
+      Eigen::Matrix<local_scalar_t__,-1,1> h =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      current_statement__ = 3;
+      h = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(Nr);
+      Eigen::Matrix<local_scalar_t__,-1,1> ar =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(2, DUMMY_VAR__);
+      current_statement__ = 4;
+      ar = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(2);
+      local_scalar_t__ ma = DUMMY_VAR__;
+      current_statement__ = 5;
+      ma = in__.template read<local_scalar_t__>();
+      local_scalar_t__ phi_beta = DUMMY_VAR__;
+      current_statement__ = 6;
+      phi_beta = in__.template read_constrain_lub<local_scalar_t__,
+                   jacobian__>(0, 1, lp__);
+      local_scalar_t__ sigma2 = DUMMY_VAR__;
+      current_statement__ = 7;
+      sigma2 = in__.template read_constrain_lb<local_scalar_t__,
+                 jacobian__>(0, lp__);
+      local_scalar_t__ Intercept = DUMMY_VAR__;
+      current_statement__ = 8;
+      Intercept = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<local_scalar_t__,-1,1> mean_price =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 9;
+      mean_price = in__.template read<
+                     Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      Eigen::Matrix<local_scalar_t__,-1,1> sigma_price =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 10;
+      sigma_price = in__.template read_constrain_lb<
+                      Eigen::Matrix<local_scalar_t__,-1,1>, jacobian__>(0.0,
+                      lp__, N);
+      local_scalar_t__ theta = DUMMY_VAR__;
+      current_statement__ = 11;
+      theta = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<local_scalar_t__,-1,1> upper_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 12;
+      upper_test = in__.template read_constrain_ub<
+                     Eigen::Matrix<local_scalar_t__,-1,1>, jacobian__>(ma,
+                     lp__, N);
+      Eigen::Matrix<local_scalar_t__,-1,1> lower_upper_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 13;
+      lower_upper_test = in__.template read_constrain_lub<
+                           Eigen::Matrix<local_scalar_t__,-1,1>,
+                           jacobian__>(sigma_price, upper_test, lp__, N);
+      current_statement__ = 13;
+      stan::math::check_matching_dims("constraint", "lower_upper_test",
+        lower_upper_test, "lower", sigma_price);
+      current_statement__ = 13;
+      stan::math::check_matching_dims("constraint", "lower_upper_test",
+        lower_upper_test, "upper", upper_test);
+      Eigen::Matrix<local_scalar_t__,1,-1> row_vec_lower_upper_test =
+        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 14;
+      row_vec_lower_upper_test = in__.template read_constrain_lub<
+                                   Eigen::Matrix<local_scalar_t__,1,-1>,
+                                   jacobian__>(stan::math::transpose(
+                                                 sigma_price),
+                                   stan::math::transpose(upper_test), lp__,
+                                   N);
+      current_statement__ = 14;
+      stan::math::check_matching_dims("constraint",
+        "row_vec_lower_upper_test", row_vec_lower_upper_test, "lower",
+        stan::math::transpose(sigma_price));
+      current_statement__ = 14;
+      stan::math::check_matching_dims("constraint",
+        "row_vec_lower_upper_test", row_vec_lower_upper_test, "upper",
+        stan::math::transpose(upper_test));
+      Eigen::Matrix<local_scalar_t__,-1,1> offset_mult_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 15;
+      offset_mult_test = in__.template read_constrain_offset_multiplier<
+                           Eigen::Matrix<local_scalar_t__,-1,1>,
+                           jacobian__>(mean_price, sigma_price, lp__, N);
+      current_statement__ = 15;
+      stan::math::check_matching_dims("constraint", "offset_mult_test",
+        offset_mult_test, "offset", mean_price);
+      current_statement__ = 15;
+      stan::math::check_matching_dims("constraint", "offset_mult_test",
+        offset_mult_test, "multiplier", sigma_price);
+      Eigen::Matrix<local_scalar_t__,-1,1> ordered_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 16;
+      ordered_test = in__.template read_constrain_ordered<
+                       Eigen::Matrix<local_scalar_t__,-1,1>,
+                       jacobian__>(lp__, N);
+      Eigen::Matrix<local_scalar_t__,-1,1> unit_vec_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 17;
+      unit_vec_test = in__.template read_constrain_unit_vector<
+                        Eigen::Matrix<local_scalar_t__,-1,1>,
+                        jacobian__>(lp__, N);
+      Eigen::Matrix<local_scalar_t__,-1,1> pos_ordered_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 18;
+      pos_ordered_test = in__.template read_constrain_positive_ordered<
+                           Eigen::Matrix<local_scalar_t__,-1,1>,
+                           jacobian__>(lp__, N);
+      Eigen::Matrix<local_scalar_t__,-1,-1> corr_matrix_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, N, DUMMY_VAR__);
+      current_statement__ = 19;
+      corr_matrix_test = in__.template read_constrain_corr_matrix<
+                           Eigen::Matrix<local_scalar_t__,-1,-1>,
+                           jacobian__>(lp__, N);
+      Eigen::Matrix<local_scalar_t__,-1,-1> cov_matrix_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, N, DUMMY_VAR__);
+      current_statement__ = 20;
+      cov_matrix_test = in__.template read_constrain_cov_matrix<
+                          Eigen::Matrix<local_scalar_t__,-1,-1>,
+                          jacobian__>(lp__, N);
+      Eigen::Matrix<local_scalar_t__,-1,-1> chol_fac_cov_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(K, K, DUMMY_VAR__);
+      current_statement__ = 21;
+      chol_fac_cov_test = in__.template read_constrain_cholesky_factor_cov<
+                            Eigen::Matrix<local_scalar_t__,-1,-1>,
+                            jacobian__>(lp__, K, K);
+      Eigen::Matrix<local_scalar_t__,-1,-1> chol_fac_corr_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(K, K, DUMMY_VAR__);
+      current_statement__ = 22;
+      chol_fac_corr_test = in__.template read_constrain_cholesky_factor_corr<
+                             Eigen::Matrix<local_scalar_t__,-1,-1>,
+                             jacobian__>(lp__, K);
+      local_scalar_t__ phi = DUMMY_VAR__;
+      current_statement__ = 23;
+      phi = stan::math::fma(phi_beta, 2.0, -(1.0));
+      local_scalar_t__ sigma = DUMMY_VAR__;
+      current_statement__ = 24;
+      sigma = stan::math::sqrt(sigma2);
+      Eigen::Matrix<local_scalar_t__,-1,1> prices =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 25;
+      stan::model::assign(prices, stan::math::add(mid_price, high_low_est),
+        "assigning variable prices");
+      Eigen::Matrix<local_scalar_t__,-1,1> prices_diff =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      current_statement__ = 26;
+      stan::model::assign(prices_diff,
+        stan::math::subtract(
+          stan::model::rvalue(prices, "prices",
+            stan::model::index_min_max(2, N)),
+          stan::model::rvalue(prices, "prices",
+            stan::model::index_min_max(1, (N - 1)))),
+        "assigning variable prices_diff");
+      Eigen::Matrix<local_scalar_t__,-1,1> mu =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      current_statement__ = 27;
+      stan::model::assign(mu,
+        stan::math::add(Intercept, stan::math::multiply(X_all, b)),
+        "assigning variable mu");
+      Eigen::Matrix<local_scalar_t__,-1,1> err =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      current_statement__ = 32;
+      stan::model::assign(err, stan::math::subtract(prices_diff, mu),
+        "assigning variable err");
+      current_statement__ = 33;
+      stan::model::assign(mu,
+        stan::math::add(
+          stan::model::deep_copy(
+            stan::model::rvalue(mu, "mu", stan::model::index_min_max(2, Nr))),
+          stan::math::add(
+            stan::math::multiply(
+              stan::model::rvalue(err, "err",
+                stan::model::index_min_max(1, (Nr - 1))), ma),
+            stan::math::multiply(
+              stan::model::rvalue(prices_diff, "prices_diff",
+                stan::model::index_min_max(1, (Nr - 1))),
+              stan::model::rvalue(ar, "ar", stan::model::index_uni(1))))),
+        "assigning variable mu", stan::model::index_min_max(2, Nr));
+      current_statement__ = 34;
+      stan::model::assign(mu,
+        stan::math::add(
+          stan::model::deep_copy(
+            stan::model::rvalue(mu, "mu", stan::model::index_min_max(3, Nr))),
+          stan::math::multiply(
+            stan::model::rvalue(prices_diff, "prices_diff",
+              stan::model::index_min_max(1, (Nr - 2))),
+            stan::model::rvalue(ar, "ar", stan::model::index_uni(2)))),
+        "assigning variable mu", stan::model::index_min_max(3, Nr));
+      current_statement__ = 35;
+      stan::model::assign(err, stan::math::subtract(prices_diff, mu),
+        "assigning variable err");
+      Eigen::Matrix<local_scalar_t__,-1,1> h_i_mean =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      Eigen::Matrix<local_scalar_t__,-1,1> h_i_sigma =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      current_statement__ = 36;
+      stan::model::assign(h_i_mean, 0.0, "assigning variable h_i_mean",
+        stan::model::index_uni(1));
+      current_statement__ = 37;
+      stan::model::assign(h_i_sigma,
+        stan::math::pow((1 - stan::math::square(phi)), -(0.5)),
+        "assigning variable h_i_sigma", stan::model::index_uni(1));
+      current_statement__ = 38;
+      stan::model::assign(h_i_sigma, stan::math::rep_vector(1.0, (Nr - 1)),
+        "assigning variable h_i_sigma", stan::model::index_min_max(2, Nr));
+      current_statement__ = 39;
+      stan::model::assign(h_i_mean,
+        stan::math::add(
+          stan::math::multiply(phi,
+            stan::model::rvalue(h, "h",
+              stan::model::index_min_max(1, (Nr - 1)))),
+          stan::math::multiply(theta,
+            stan::math::square(
+              stan::model::rvalue(err, "err",
+                stan::model::index_min_max(1, (Nr - 1)))))),
+        "assigning variable h_i_mean", stan::model::index_min_max(2, Nr));
+      Eigen::Matrix<local_scalar_t__,-1,1> h_sigma =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      current_statement__ = 31;
+      stan::model::assign(h_sigma,
+        stan::math::add(
+          stan::math::exp(
+            stan::math::add(stan::math::multiply(h, (0.5 * sigma)),
+              stan::math::multiply(0.5, mu))), 0.000001),
+        "assigning variable h_sigma");
+      current_statement__ = 23;
+      stan::math::check_greater_or_equal(function__, "phi", phi, -(1));
+      current_statement__ = 23;
+      stan::math::check_less_or_equal(function__, "phi", phi, 1);
+      current_statement__ = 24;
+      stan::math::check_greater_or_equal(function__, "sigma", sigma, 0);
+      current_statement__ = 30;
+      stan::math::check_greater_or_equal(function__, "h_i_sigma", h_i_sigma,
+        0);
+      {
+        current_statement__ = 40;
+        lp_accum__.add(stan::math::multiply(-(2),
+                         stan::math::log(sigma_price)));
+        current_statement__ = 41;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(Intercept,
+                         mu_prior_mu, mu_prior_sigma));
+        current_statement__ = 42;
+        lp_accum__.add(stan::math::beta_lpdf<propto__>(phi_beta, phi_prior_a,
+                         phi_prior_b));
+        current_statement__ = 43;
+        lp_accum__.add(stan::math::gamma_lpdf<propto__>(sigma2,
+                         sigma_prior_shape, sigma_prior_rate));
+        current_statement__ = 44;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(ar, 0, .2));
+        current_statement__ = 45;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(ma, 0, .2));
+        current_statement__ = 46;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(h, h_i_mean,
+                         h_i_sigma));
+        current_statement__ = 47;
+        lp_accum__.add(stan::math::student_t_lpdf<propto__>(sigma_price, 3,
+                         1, 1));
+        current_statement__ = 48;
+        lp_accum__.add(stan::math::uniform_lpdf<propto__>(high_low_est,
+                         diff_low_mid, diff_high_mid));
+        current_statement__ = 49;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(prices, mean_price,
+                         sigma_price));
+        current_statement__ = 50;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(prices_diff, mu,
+                         h_sigma));
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  // Reverse mode autodiff log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "constraints_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,1> high_low_est =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 1;
+      high_low_est = in__.template read_constrain_lub<
+                       Eigen::Matrix<local_scalar_t__,-1,1>,
+                       jacobian__>(diff_low_mid, diff_high_mid, lp__, N);
+      current_statement__ = 1;
+      stan::math::check_matching_dims("constraint", "high_low_est",
+        high_low_est, "lower", diff_low_mid);
+      current_statement__ = 1;
+      stan::math::check_matching_dims("constraint", "high_low_est",
+        high_low_est, "upper", diff_high_mid);
+      Eigen::Matrix<local_scalar_t__,-1,1> b =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(K, DUMMY_VAR__);
+      current_statement__ = 2;
+      b = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(K);
+      Eigen::Matrix<local_scalar_t__,-1,1> h =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      current_statement__ = 3;
+      h = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(Nr);
+      Eigen::Matrix<local_scalar_t__,-1,1> ar =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(2, DUMMY_VAR__);
+      current_statement__ = 4;
+      ar = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(2);
+      local_scalar_t__ ma = DUMMY_VAR__;
+      current_statement__ = 5;
+      ma = in__.template read<local_scalar_t__>();
+      local_scalar_t__ phi_beta = DUMMY_VAR__;
+      current_statement__ = 6;
+      phi_beta = in__.template read_constrain_lub<local_scalar_t__,
+                   jacobian__>(0, 1, lp__);
+      local_scalar_t__ sigma2 = DUMMY_VAR__;
+      current_statement__ = 7;
+      sigma2 = in__.template read_constrain_lb<local_scalar_t__,
+                 jacobian__>(0, lp__);
+      local_scalar_t__ Intercept = DUMMY_VAR__;
+      current_statement__ = 8;
+      Intercept = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<local_scalar_t__,-1,1> mean_price =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 9;
+      mean_price = in__.template read<
+                     Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      Eigen::Matrix<local_scalar_t__,-1,1> sigma_price =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 10;
+      sigma_price = in__.template read_constrain_lb<
+                      Eigen::Matrix<local_scalar_t__,-1,1>, jacobian__>(0.0,
+                      lp__, N);
+      local_scalar_t__ theta = DUMMY_VAR__;
+      current_statement__ = 11;
+      theta = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<local_scalar_t__,-1,1> upper_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 12;
+      upper_test = in__.template read_constrain_ub<
+                     Eigen::Matrix<local_scalar_t__,-1,1>, jacobian__>(ma,
+                     lp__, N);
+      Eigen::Matrix<local_scalar_t__,-1,1> lower_upper_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 13;
+      lower_upper_test = in__.template read_constrain_lub<
+                           Eigen::Matrix<local_scalar_t__,-1,1>,
+                           jacobian__>(sigma_price, upper_test, lp__, N);
+      current_statement__ = 13;
+      stan::math::check_matching_dims("constraint", "lower_upper_test",
+        lower_upper_test, "lower", sigma_price);
+      current_statement__ = 13;
+      stan::math::check_matching_dims("constraint", "lower_upper_test",
+        lower_upper_test, "upper", upper_test);
+      Eigen::Matrix<local_scalar_t__,1,-1> row_vec_lower_upper_test =
+        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 14;
+      row_vec_lower_upper_test = in__.template read_constrain_lub<
+                                   Eigen::Matrix<local_scalar_t__,1,-1>,
+                                   jacobian__>(stan::math::transpose(
+                                                 sigma_price),
+                                   stan::math::transpose(upper_test), lp__,
+                                   N);
+      current_statement__ = 14;
+      stan::math::check_matching_dims("constraint",
+        "row_vec_lower_upper_test", row_vec_lower_upper_test, "lower",
+        stan::math::transpose(sigma_price));
+      current_statement__ = 14;
+      stan::math::check_matching_dims("constraint",
+        "row_vec_lower_upper_test", row_vec_lower_upper_test, "upper",
+        stan::math::transpose(upper_test));
+      Eigen::Matrix<local_scalar_t__,-1,1> offset_mult_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 15;
+      offset_mult_test = in__.template read_constrain_offset_multiplier<
+                           Eigen::Matrix<local_scalar_t__,-1,1>,
+                           jacobian__>(mean_price, sigma_price, lp__, N);
+      current_statement__ = 15;
+      stan::math::check_matching_dims("constraint", "offset_mult_test",
+        offset_mult_test, "offset", mean_price);
+      current_statement__ = 15;
+      stan::math::check_matching_dims("constraint", "offset_mult_test",
+        offset_mult_test, "multiplier", sigma_price);
+      Eigen::Matrix<local_scalar_t__,-1,1> ordered_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 16;
+      ordered_test = in__.template read_constrain_ordered<
+                       Eigen::Matrix<local_scalar_t__,-1,1>,
+                       jacobian__>(lp__, N);
+      Eigen::Matrix<local_scalar_t__,-1,1> unit_vec_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 17;
+      unit_vec_test = in__.template read_constrain_unit_vector<
+                        Eigen::Matrix<local_scalar_t__,-1,1>,
+                        jacobian__>(lp__, N);
+      Eigen::Matrix<local_scalar_t__,-1,1> pos_ordered_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 18;
+      pos_ordered_test = in__.template read_constrain_positive_ordered<
+                           Eigen::Matrix<local_scalar_t__,-1,1>,
+                           jacobian__>(lp__, N);
+      Eigen::Matrix<local_scalar_t__,-1,-1> corr_matrix_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, N, DUMMY_VAR__);
+      current_statement__ = 19;
+      corr_matrix_test = in__.template read_constrain_corr_matrix<
+                           Eigen::Matrix<local_scalar_t__,-1,-1>,
+                           jacobian__>(lp__, N);
+      Eigen::Matrix<local_scalar_t__,-1,-1> cov_matrix_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, N, DUMMY_VAR__);
+      current_statement__ = 20;
+      cov_matrix_test = in__.template read_constrain_cov_matrix<
+                          Eigen::Matrix<local_scalar_t__,-1,-1>,
+                          jacobian__>(lp__, N);
+      Eigen::Matrix<local_scalar_t__,-1,-1> chol_fac_cov_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(K, K, DUMMY_VAR__);
+      current_statement__ = 21;
+      chol_fac_cov_test = in__.template read_constrain_cholesky_factor_cov<
+                            Eigen::Matrix<local_scalar_t__,-1,-1>,
+                            jacobian__>(lp__, K, K);
+      Eigen::Matrix<local_scalar_t__,-1,-1> chol_fac_corr_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(K, K, DUMMY_VAR__);
+      current_statement__ = 22;
+      chol_fac_corr_test = in__.template read_constrain_cholesky_factor_corr<
+                             Eigen::Matrix<local_scalar_t__,-1,-1>,
+                             jacobian__>(lp__, K);
+      local_scalar_t__ phi = DUMMY_VAR__;
+      current_statement__ = 23;
+      phi = stan::math::fma(phi_beta, 2.0, -(1.0));
+      local_scalar_t__ sigma = DUMMY_VAR__;
+      current_statement__ = 24;
+      sigma = stan::math::sqrt(sigma2);
+      Eigen::Matrix<local_scalar_t__,-1,1> prices =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 25;
+      stan::model::assign(prices, stan::math::add(mid_price, high_low_est),
+        "assigning variable prices");
+      Eigen::Matrix<local_scalar_t__,-1,1> prices_diff =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      current_statement__ = 26;
+      stan::model::assign(prices_diff,
+        stan::math::subtract(
+          stan::model::rvalue(prices, "prices",
+            stan::model::index_min_max(2, N)),
+          stan::model::rvalue(prices, "prices",
+            stan::model::index_min_max(1, (N - 1)))),
+        "assigning variable prices_diff");
+      Eigen::Matrix<local_scalar_t__,-1,1> mu =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      current_statement__ = 27;
+      stan::model::assign(mu,
+        stan::math::add(Intercept, stan::math::multiply(X_all, b)),
+        "assigning variable mu");
+      Eigen::Matrix<local_scalar_t__,-1,1> err =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      current_statement__ = 32;
+      stan::model::assign(err, stan::math::subtract(prices_diff, mu),
+        "assigning variable err");
+      current_statement__ = 33;
+      stan::model::assign(mu,
+        stan::math::add(
+          stan::model::deep_copy(
+            stan::model::rvalue(mu, "mu", stan::model::index_min_max(2, Nr))),
+          stan::math::add(
+            stan::math::multiply(
+              stan::model::rvalue(err, "err",
+                stan::model::index_min_max(1, (Nr - 1))), ma),
+            stan::math::multiply(
+              stan::model::rvalue(prices_diff, "prices_diff",
+                stan::model::index_min_max(1, (Nr - 1))),
+              stan::model::rvalue(ar, "ar", stan::model::index_uni(1))))),
+        "assigning variable mu", stan::model::index_min_max(2, Nr));
+      current_statement__ = 34;
+      stan::model::assign(mu,
+        stan::math::add(
+          stan::model::deep_copy(
+            stan::model::rvalue(mu, "mu", stan::model::index_min_max(3, Nr))),
+          stan::math::multiply(
+            stan::model::rvalue(prices_diff, "prices_diff",
+              stan::model::index_min_max(1, (Nr - 2))),
+            stan::model::rvalue(ar, "ar", stan::model::index_uni(2)))),
+        "assigning variable mu", stan::model::index_min_max(3, Nr));
+      current_statement__ = 35;
+      stan::model::assign(err, stan::math::subtract(prices_diff, mu),
+        "assigning variable err");
+      Eigen::Matrix<local_scalar_t__,-1,1> h_i_mean =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      Eigen::Matrix<local_scalar_t__,-1,1> h_i_sigma =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      current_statement__ = 36;
+      stan::model::assign(h_i_mean, 0.0, "assigning variable h_i_mean",
+        stan::model::index_uni(1));
+      current_statement__ = 37;
+      stan::model::assign(h_i_sigma,
+        stan::math::pow((1 - stan::math::square(phi)), -(0.5)),
+        "assigning variable h_i_sigma", stan::model::index_uni(1));
+      current_statement__ = 38;
+      stan::model::assign(h_i_sigma, stan::math::rep_vector(1.0, (Nr - 1)),
+        "assigning variable h_i_sigma", stan::model::index_min_max(2, Nr));
+      current_statement__ = 39;
+      stan::model::assign(h_i_mean,
+        stan::math::add(
+          stan::math::multiply(phi,
+            stan::model::rvalue(h, "h",
+              stan::model::index_min_max(1, (Nr - 1)))),
+          stan::math::multiply(theta,
+            stan::math::square(
+              stan::model::rvalue(err, "err",
+                stan::model::index_min_max(1, (Nr - 1)))))),
+        "assigning variable h_i_mean", stan::model::index_min_max(2, Nr));
+      Eigen::Matrix<local_scalar_t__,-1,1> h_sigma =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      current_statement__ = 31;
+      stan::model::assign(h_sigma,
+        stan::math::add(
+          stan::math::exp(
+            stan::math::add(stan::math::multiply(h, (0.5 * sigma)),
+              stan::math::multiply(0.5, mu))), 0.000001),
+        "assigning variable h_sigma");
+      current_statement__ = 23;
+      stan::math::check_greater_or_equal(function__, "phi", phi, -(1));
+      current_statement__ = 23;
+      stan::math::check_less_or_equal(function__, "phi", phi, 1);
+      current_statement__ = 24;
+      stan::math::check_greater_or_equal(function__, "sigma", sigma, 0);
+      current_statement__ = 30;
+      stan::math::check_greater_or_equal(function__, "h_i_sigma", h_i_sigma,
+        0);
+      {
+        current_statement__ = 40;
+        lp_accum__.add(stan::math::multiply(-(2),
+                         stan::math::log(sigma_price)));
+        current_statement__ = 41;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(Intercept,
+                         mu_prior_mu, mu_prior_sigma));
+        current_statement__ = 42;
+        lp_accum__.add(stan::math::beta_lpdf<propto__>(phi_beta, phi_prior_a,
+                         phi_prior_b));
+        current_statement__ = 43;
+        lp_accum__.add(stan::math::gamma_lpdf<propto__>(sigma2,
+                         sigma_prior_shape, sigma_prior_rate));
+        current_statement__ = 44;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(ar, 0, .2));
+        current_statement__ = 45;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(ma, 0, .2));
+        current_statement__ = 46;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(h, h_i_mean,
+                         h_i_sigma));
+        current_statement__ = 47;
+        lp_accum__.add(stan::math::student_t_lpdf<propto__>(sigma_price, 3,
+                         1, 1));
+        current_statement__ = 48;
+        lp_accum__.add(stan::math::uniform_lpdf<propto__>(high_low_est,
+                         diff_low_mid, diff_high_mid));
+        current_statement__ = 49;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(prices, mean_price,
+                         sigma_price));
+        current_statement__ = 50;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(prices_diff, mu,
+                         h_sigma));
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  template <typename RNG, typename VecR, typename VecI, typename VecVar,
+            stan::require_vector_like_vt<std::is_floating_point,
+            VecR>* = nullptr, stan::require_vector_like_vt<std::is_integral,
+            VecI>* = nullptr, stan::require_vector_vt<std::is_floating_point,
+            VecVar>* = nullptr>
+  inline void
+  write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__,
+                   VecVar& vars__, const bool
+                   emit_transformed_parameters__ = true, const bool
+                   emit_generated_quantities__ = true, std::ostream*
+                   pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    static constexpr bool propto__ = true;
+    // suppress unused var warning
+    (void) propto__;
+    double lp__ = 0.0;
+    // suppress unused var warning
+    (void) lp__;
+    int current_statement__ = 0;
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    constexpr bool jacobian__ = false;
+    // suppress unused var warning
+    (void) jacobian__;
+    static constexpr const char* function__ =
+      "constraints_model_namespace::write_array";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<double,-1,1> high_low_est =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 1;
+      high_low_est = in__.template read_constrain_lub<
+                       Eigen::Matrix<local_scalar_t__,-1,1>,
+                       jacobian__>(diff_low_mid, diff_high_mid, lp__, N);
+      current_statement__ = 1;
+      stan::math::check_matching_dims("constraint", "high_low_est",
+        high_low_est, "lower", diff_low_mid);
+      current_statement__ = 1;
+      stan::math::check_matching_dims("constraint", "high_low_est",
+        high_low_est, "upper", diff_high_mid);
+      Eigen::Matrix<double,-1,1> b =
+        Eigen::Matrix<double,-1,1>::Constant(K,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 2;
+      b = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(K);
+      Eigen::Matrix<double,-1,1> h =
+        Eigen::Matrix<double,-1,1>::Constant(Nr,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 3;
+      h = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(Nr);
+      Eigen::Matrix<double,-1,1> ar =
+        Eigen::Matrix<double,-1,1>::Constant(2,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 4;
+      ar = in__.template read<Eigen::Matrix<local_scalar_t__,-1,1>>(2);
+      double ma = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 5;
+      ma = in__.template read<local_scalar_t__>();
+      double phi_beta = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 6;
+      phi_beta = in__.template read_constrain_lub<local_scalar_t__,
+                   jacobian__>(0, 1, lp__);
+      double sigma2 = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 7;
+      sigma2 = in__.template read_constrain_lb<local_scalar_t__,
+                 jacobian__>(0, lp__);
+      double Intercept = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 8;
+      Intercept = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<double,-1,1> mean_price =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 9;
+      mean_price = in__.template read<
+                     Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      Eigen::Matrix<double,-1,1> sigma_price =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 10;
+      sigma_price = in__.template read_constrain_lb<
+                      Eigen::Matrix<local_scalar_t__,-1,1>, jacobian__>(0.0,
+                      lp__, N);
+      double theta = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 11;
+      theta = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<double,-1,1> upper_test =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 12;
+      upper_test = in__.template read_constrain_ub<
+                     Eigen::Matrix<local_scalar_t__,-1,1>, jacobian__>(ma,
+                     lp__, N);
+      Eigen::Matrix<double,-1,1> lower_upper_test =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 13;
+      lower_upper_test = in__.template read_constrain_lub<
+                           Eigen::Matrix<local_scalar_t__,-1,1>,
+                           jacobian__>(sigma_price, upper_test, lp__, N);
+      current_statement__ = 13;
+      stan::math::check_matching_dims("constraint", "lower_upper_test",
+        lower_upper_test, "lower", sigma_price);
+      current_statement__ = 13;
+      stan::math::check_matching_dims("constraint", "lower_upper_test",
+        lower_upper_test, "upper", upper_test);
+      Eigen::Matrix<double,1,-1> row_vec_lower_upper_test =
+        Eigen::Matrix<double,1,-1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 14;
+      row_vec_lower_upper_test = in__.template read_constrain_lub<
+                                   Eigen::Matrix<local_scalar_t__,1,-1>,
+                                   jacobian__>(stan::math::transpose(
+                                                 sigma_price),
+                                   stan::math::transpose(upper_test), lp__,
+                                   N);
+      current_statement__ = 14;
+      stan::math::check_matching_dims("constraint",
+        "row_vec_lower_upper_test", row_vec_lower_upper_test, "lower",
+        stan::math::transpose(sigma_price));
+      current_statement__ = 14;
+      stan::math::check_matching_dims("constraint",
+        "row_vec_lower_upper_test", row_vec_lower_upper_test, "upper",
+        stan::math::transpose(upper_test));
+      Eigen::Matrix<double,-1,1> offset_mult_test =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 15;
+      offset_mult_test = in__.template read_constrain_offset_multiplier<
+                           Eigen::Matrix<local_scalar_t__,-1,1>,
+                           jacobian__>(mean_price, sigma_price, lp__, N);
+      current_statement__ = 15;
+      stan::math::check_matching_dims("constraint", "offset_mult_test",
+        offset_mult_test, "offset", mean_price);
+      current_statement__ = 15;
+      stan::math::check_matching_dims("constraint", "offset_mult_test",
+        offset_mult_test, "multiplier", sigma_price);
+      Eigen::Matrix<double,-1,1> ordered_test =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 16;
+      ordered_test = in__.template read_constrain_ordered<
+                       Eigen::Matrix<local_scalar_t__,-1,1>,
+                       jacobian__>(lp__, N);
+      Eigen::Matrix<double,-1,1> unit_vec_test =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 17;
+      unit_vec_test = in__.template read_constrain_unit_vector<
+                        Eigen::Matrix<local_scalar_t__,-1,1>,
+                        jacobian__>(lp__, N);
+      Eigen::Matrix<double,-1,1> pos_ordered_test =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 18;
+      pos_ordered_test = in__.template read_constrain_positive_ordered<
+                           Eigen::Matrix<local_scalar_t__,-1,1>,
+                           jacobian__>(lp__, N);
+      Eigen::Matrix<double,-1,-1> corr_matrix_test =
+        Eigen::Matrix<double,-1,-1>::Constant(N, N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 19;
+      corr_matrix_test = in__.template read_constrain_corr_matrix<
+                           Eigen::Matrix<local_scalar_t__,-1,-1>,
+                           jacobian__>(lp__, N);
+      Eigen::Matrix<double,-1,-1> cov_matrix_test =
+        Eigen::Matrix<double,-1,-1>::Constant(N, N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 20;
+      cov_matrix_test = in__.template read_constrain_cov_matrix<
+                          Eigen::Matrix<local_scalar_t__,-1,-1>,
+                          jacobian__>(lp__, N);
+      Eigen::Matrix<double,-1,-1> chol_fac_cov_test =
+        Eigen::Matrix<double,-1,-1>::Constant(K, K,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 21;
+      chol_fac_cov_test = in__.template read_constrain_cholesky_factor_cov<
+                            Eigen::Matrix<local_scalar_t__,-1,-1>,
+                            jacobian__>(lp__, K, K);
+      Eigen::Matrix<double,-1,-1> chol_fac_corr_test =
+        Eigen::Matrix<double,-1,-1>::Constant(K, K,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 22;
+      chol_fac_corr_test = in__.template read_constrain_cholesky_factor_corr<
+                             Eigen::Matrix<local_scalar_t__,-1,-1>,
+                             jacobian__>(lp__, K);
+      double phi = std::numeric_limits<double>::quiet_NaN();
+      double sigma = std::numeric_limits<double>::quiet_NaN();
+      Eigen::Matrix<double,-1,1> prices =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,1> prices_diff =
+        Eigen::Matrix<double,-1,1>::Constant(Nr,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,1> mu =
+        Eigen::Matrix<double,-1,1>::Constant(Nr,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,1> err =
+        Eigen::Matrix<double,-1,1>::Constant(Nr,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,1> h_i_mean =
+        Eigen::Matrix<double,-1,1>::Constant(Nr,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,1> h_i_sigma =
+        Eigen::Matrix<double,-1,1>::Constant(Nr,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,1> h_sigma =
+        Eigen::Matrix<double,-1,1>::Constant(Nr,
+          std::numeric_limits<double>::quiet_NaN());
+      out__.write(high_low_est);
+      out__.write(b);
+      out__.write(h);
+      out__.write(ar);
+      out__.write(ma);
+      out__.write(phi_beta);
+      out__.write(sigma2);
+      out__.write(Intercept);
+      out__.write(mean_price);
+      out__.write(sigma_price);
+      out__.write(theta);
+      out__.write(upper_test);
+      out__.write(lower_upper_test);
+      out__.write(row_vec_lower_upper_test);
+      out__.write(offset_mult_test);
+      out__.write(ordered_test);
+      out__.write(unit_vec_test);
+      out__.write(pos_ordered_test);
+      out__.write(corr_matrix_test);
+      out__.write(cov_matrix_test);
+      out__.write(chol_fac_cov_test);
+      out__.write(chol_fac_corr_test);
+      if (stan::math::logical_negation(
+            (stan::math::primitive_value(emit_transformed_parameters__) ||
+            stan::math::primitive_value(emit_generated_quantities__)))) {
+        return ;
+      }
+      current_statement__ = 23;
+      phi = stan::math::fma(phi_beta, 2.0, -(1.0));
+      current_statement__ = 24;
+      sigma = stan::math::sqrt(sigma2);
+      current_statement__ = 25;
+      stan::model::assign(prices, stan::math::add(mid_price, high_low_est),
+        "assigning variable prices");
+      current_statement__ = 26;
+      stan::model::assign(prices_diff,
+        stan::math::subtract(
+          stan::model::rvalue(prices, "prices",
+            stan::model::index_min_max(2, N)),
+          stan::model::rvalue(prices, "prices",
+            stan::model::index_min_max(1, (N - 1)))),
+        "assigning variable prices_diff");
+      current_statement__ = 27;
+      stan::model::assign(mu,
+        stan::math::add(Intercept, stan::math::multiply(X_all, b)),
+        "assigning variable mu");
+      current_statement__ = 32;
+      stan::model::assign(err, stan::math::subtract(prices_diff, mu),
+        "assigning variable err");
+      current_statement__ = 33;
+      stan::model::assign(mu,
+        stan::math::add(
+          stan::model::deep_copy(
+            stan::model::rvalue(mu, "mu", stan::model::index_min_max(2, Nr))),
+          stan::math::add(
+            stan::math::multiply(
+              stan::model::rvalue(err, "err",
+                stan::model::index_min_max(1, (Nr - 1))), ma),
+            stan::math::multiply(
+              stan::model::rvalue(prices_diff, "prices_diff",
+                stan::model::index_min_max(1, (Nr - 1))),
+              stan::model::rvalue(ar, "ar", stan::model::index_uni(1))))),
+        "assigning variable mu", stan::model::index_min_max(2, Nr));
+      current_statement__ = 34;
+      stan::model::assign(mu,
+        stan::math::add(
+          stan::model::deep_copy(
+            stan::model::rvalue(mu, "mu", stan::model::index_min_max(3, Nr))),
+          stan::math::multiply(
+            stan::model::rvalue(prices_diff, "prices_diff",
+              stan::model::index_min_max(1, (Nr - 2))),
+            stan::model::rvalue(ar, "ar", stan::model::index_uni(2)))),
+        "assigning variable mu", stan::model::index_min_max(3, Nr));
+      current_statement__ = 35;
+      stan::model::assign(err, stan::math::subtract(prices_diff, mu),
+        "assigning variable err");
+      current_statement__ = 36;
+      stan::model::assign(h_i_mean, 0.0, "assigning variable h_i_mean",
+        stan::model::index_uni(1));
+      current_statement__ = 37;
+      stan::model::assign(h_i_sigma,
+        stan::math::pow((1 - stan::math::square(phi)), -(0.5)),
+        "assigning variable h_i_sigma", stan::model::index_uni(1));
+      current_statement__ = 38;
+      stan::model::assign(h_i_sigma, stan::math::rep_vector(1.0, (Nr - 1)),
+        "assigning variable h_i_sigma", stan::model::index_min_max(2, Nr));
+      current_statement__ = 39;
+      stan::model::assign(h_i_mean,
+        stan::math::add(
+          stan::math::multiply(phi,
+            stan::model::rvalue(h, "h",
+              stan::model::index_min_max(1, (Nr - 1)))),
+          stan::math::multiply(theta,
+            stan::math::square(
+              stan::model::rvalue(err, "err",
+                stan::model::index_min_max(1, (Nr - 1)))))),
+        "assigning variable h_i_mean", stan::model::index_min_max(2, Nr));
+      current_statement__ = 31;
+      stan::model::assign(h_sigma,
+        stan::math::add(
+          stan::math::exp(
+            stan::math::add(stan::math::multiply(h, (0.5 * sigma)),
+              stan::math::multiply(0.5, mu))), 0.000001),
+        "assigning variable h_sigma");
+      current_statement__ = 23;
+      stan::math::check_greater_or_equal(function__, "phi", phi, -(1));
+      current_statement__ = 23;
+      stan::math::check_less_or_equal(function__, "phi", phi, 1);
+      current_statement__ = 24;
+      stan::math::check_greater_or_equal(function__, "sigma", sigma, 0);
+      current_statement__ = 30;
+      stan::math::check_greater_or_equal(function__, "h_i_sigma", h_i_sigma,
+        0);
+      if (emit_transformed_parameters__) {
+        out__.write(phi);
+        out__.write(sigma);
+        out__.write(prices);
+        out__.write(prices_diff);
+        out__.write(mu);
+        out__.write(err);
+        out__.write(h_i_mean);
+        out__.write(h_i_sigma);
+        out__.write(h_sigma);
+      }
+      if (stan::math::logical_negation(emit_generated_quantities__)) {
+        return ;
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, typename VecI,
+            stan::require_vector_t<VecVar>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr>
+  inline void
+  unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__,
+                         VecVar& vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,1> high_low_est =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 1;
+      stan::model::assign(high_low_est,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(N),
+        "assigning variable high_low_est");
+      out__.write_free_lub(diff_low_mid, diff_high_mid, high_low_est);
+      Eigen::Matrix<local_scalar_t__,-1,1> b =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(K, DUMMY_VAR__);
+      current_statement__ = 2;
+      stan::model::assign(b,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(K),
+        "assigning variable b");
+      out__.write(b);
+      Eigen::Matrix<local_scalar_t__,-1,1> h =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      current_statement__ = 3;
+      stan::model::assign(h,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(Nr),
+        "assigning variable h");
+      out__.write(h);
+      Eigen::Matrix<local_scalar_t__,-1,1> ar =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(2, DUMMY_VAR__);
+      current_statement__ = 4;
+      stan::model::assign(ar,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(2),
+        "assigning variable ar");
+      out__.write(ar);
+      local_scalar_t__ ma = DUMMY_VAR__;
+      current_statement__ = 5;
+      ma = in__.read<local_scalar_t__>();
+      out__.write(ma);
+      local_scalar_t__ phi_beta = DUMMY_VAR__;
+      current_statement__ = 6;
+      phi_beta = in__.read<local_scalar_t__>();
+      out__.write_free_lub(0, 1, phi_beta);
+      local_scalar_t__ sigma2 = DUMMY_VAR__;
+      current_statement__ = 7;
+      sigma2 = in__.read<local_scalar_t__>();
+      out__.write_free_lb(0, sigma2);
+      local_scalar_t__ Intercept = DUMMY_VAR__;
+      current_statement__ = 8;
+      Intercept = in__.read<local_scalar_t__>();
+      out__.write(Intercept);
+      Eigen::Matrix<local_scalar_t__,-1,1> mean_price =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 9;
+      stan::model::assign(mean_price,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(N),
+        "assigning variable mean_price");
+      out__.write(mean_price);
+      Eigen::Matrix<local_scalar_t__,-1,1> sigma_price =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 10;
+      stan::model::assign(sigma_price,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(N),
+        "assigning variable sigma_price");
+      out__.write_free_lb(0.0, sigma_price);
+      local_scalar_t__ theta = DUMMY_VAR__;
+      current_statement__ = 11;
+      theta = in__.read<local_scalar_t__>();
+      out__.write(theta);
+      Eigen::Matrix<local_scalar_t__,-1,1> upper_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 12;
+      stan::model::assign(upper_test,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(N),
+        "assigning variable upper_test");
+      out__.write_free_ub(ma, upper_test);
+      Eigen::Matrix<local_scalar_t__,-1,1> lower_upper_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 13;
+      stan::model::assign(lower_upper_test,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(N),
+        "assigning variable lower_upper_test");
+      out__.write_free_lub(sigma_price, upper_test, lower_upper_test);
+      Eigen::Matrix<local_scalar_t__,1,-1> row_vec_lower_upper_test =
+        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 14;
+      stan::model::assign(row_vec_lower_upper_test,
+        in__.read<Eigen::Matrix<local_scalar_t__,1,-1>>(N),
+        "assigning variable row_vec_lower_upper_test");
+      out__.write_free_lub(stan::math::transpose(sigma_price),
+        stan::math::transpose(upper_test), row_vec_lower_upper_test);
+      Eigen::Matrix<local_scalar_t__,-1,1> offset_mult_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 15;
+      stan::model::assign(offset_mult_test,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(N),
+        "assigning variable offset_mult_test");
+      out__.write_free_offset_multiplier(mean_price, sigma_price,
+        offset_mult_test);
+      Eigen::Matrix<local_scalar_t__,-1,1> ordered_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 16;
+      stan::model::assign(ordered_test,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(N),
+        "assigning variable ordered_test");
+      out__.write_free_ordered(ordered_test);
+      Eigen::Matrix<local_scalar_t__,-1,1> unit_vec_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 17;
+      stan::model::assign(unit_vec_test,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(N),
+        "assigning variable unit_vec_test");
+      out__.write_free_unit_vector(unit_vec_test);
+      Eigen::Matrix<local_scalar_t__,-1,1> pos_ordered_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 18;
+      stan::model::assign(pos_ordered_test,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(N),
+        "assigning variable pos_ordered_test");
+      out__.write_free_positive_ordered(pos_ordered_test);
+      Eigen::Matrix<local_scalar_t__,-1,-1> corr_matrix_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, N, DUMMY_VAR__);
+      current_statement__ = 19;
+      stan::model::assign(corr_matrix_test,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(N, N),
+        "assigning variable corr_matrix_test");
+      out__.write_free_corr_matrix(corr_matrix_test);
+      Eigen::Matrix<local_scalar_t__,-1,-1> cov_matrix_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, N, DUMMY_VAR__);
+      current_statement__ = 20;
+      stan::model::assign(cov_matrix_test,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(N, N),
+        "assigning variable cov_matrix_test");
+      out__.write_free_cov_matrix(cov_matrix_test);
+      Eigen::Matrix<local_scalar_t__,-1,-1> chol_fac_cov_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(K, K, DUMMY_VAR__);
+      current_statement__ = 21;
+      stan::model::assign(chol_fac_cov_test,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(K, K),
+        "assigning variable chol_fac_cov_test");
+      out__.write_free_cholesky_factor_cov(chol_fac_cov_test);
+      Eigen::Matrix<local_scalar_t__,-1,-1> chol_fac_corr_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(K, K, DUMMY_VAR__);
+      current_statement__ = 22;
+      stan::model::assign(chol_fac_corr_test,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(K, K),
+        "assigning variable chol_fac_corr_test");
+      out__.write_free_cholesky_factor_corr(chol_fac_corr_test);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, stan::require_vector_t<VecVar>* = nullptr>
+  inline void
+  transform_inits_impl(const stan::io::var_context& context__, VecVar&
+                       vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 1;
+      context__.validate_dims("parameter initialization", "high_low_est",
+        "double", std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 2;
+      context__.validate_dims("parameter initialization", "b", "double",
+        std::vector<size_t>{static_cast<size_t>(K)});
+      current_statement__ = 3;
+      context__.validate_dims("parameter initialization", "h", "double",
+        std::vector<size_t>{static_cast<size_t>(Nr)});
+      current_statement__ = 4;
+      context__.validate_dims("parameter initialization", "ar", "double",
+        std::vector<size_t>{static_cast<size_t>(2)});
+      current_statement__ = 5;
+      context__.validate_dims("parameter initialization", "ma", "double",
+        std::vector<size_t>{});
+      current_statement__ = 6;
+      context__.validate_dims("parameter initialization", "phi_beta",
+        "double", std::vector<size_t>{});
+      current_statement__ = 7;
+      context__.validate_dims("parameter initialization", "sigma2", "double",
+        std::vector<size_t>{});
+      current_statement__ = 8;
+      context__.validate_dims("parameter initialization", "Intercept",
+        "double", std::vector<size_t>{});
+      current_statement__ = 9;
+      context__.validate_dims("parameter initialization", "mean_price",
+        "double", std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 10;
+      context__.validate_dims("parameter initialization", "sigma_price",
+        "double", std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 11;
+      context__.validate_dims("parameter initialization", "theta", "double",
+        std::vector<size_t>{});
+      current_statement__ = 12;
+      context__.validate_dims("parameter initialization", "upper_test",
+        "double", std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 13;
+      context__.validate_dims("parameter initialization", "lower_upper_test",
+        "double", std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 14;
+      context__.validate_dims("parameter initialization",
+        "row_vec_lower_upper_test", "double",
+        std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 15;
+      context__.validate_dims("parameter initialization", "offset_mult_test",
+        "double", std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 16;
+      context__.validate_dims("parameter initialization", "ordered_test",
+        "double", std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 17;
+      context__.validate_dims("parameter initialization", "unit_vec_test",
+        "double", std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 18;
+      context__.validate_dims("parameter initialization", "pos_ordered_test",
+        "double", std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 19;
+      context__.validate_dims("parameter initialization", "corr_matrix_test",
+        "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(N)});
+      current_statement__ = 20;
+      context__.validate_dims("parameter initialization", "cov_matrix_test",
+        "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(N)});
+      current_statement__ = 21;
+      context__.validate_dims("parameter initialization",
+        "chol_fac_cov_test", "double",
+        std::vector<size_t>{static_cast<size_t>(K), static_cast<size_t>(K)});
+      current_statement__ = 22;
+      context__.validate_dims("parameter initialization",
+        "chol_fac_corr_test", "double",
+        std::vector<size_t>{static_cast<size_t>(K), static_cast<size_t>(K)});
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      Eigen::Matrix<local_scalar_t__,-1,1> high_low_est =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> high_low_est_flat__;
+        current_statement__ = 1;
+        high_low_est_flat__ = context__.vals_r("high_low_est");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(high_low_est, high_low_est_flat__[(pos__ - 1)],
+            "assigning variable high_low_est", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write_free_lub(diff_low_mid, diff_high_mid, high_low_est);
+      Eigen::Matrix<local_scalar_t__,-1,1> b =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(K, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> b_flat__;
+        current_statement__ = 2;
+        b_flat__ = context__.vals_r("b");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= K; ++sym1__) {
+          stan::model::assign(b, b_flat__[(pos__ - 1)],
+            "assigning variable b", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(b);
+      Eigen::Matrix<local_scalar_t__,-1,1> h =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(Nr, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> h_flat__;
+        current_statement__ = 3;
+        h_flat__ = context__.vals_r("h");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+          stan::model::assign(h, h_flat__[(pos__ - 1)],
+            "assigning variable h", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(h);
+      Eigen::Matrix<local_scalar_t__,-1,1> ar =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(2, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> ar_flat__;
+        current_statement__ = 4;
+        ar_flat__ = context__.vals_r("ar");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 2; ++sym1__) {
+          stan::model::assign(ar, ar_flat__[(pos__ - 1)],
+            "assigning variable ar", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(ar);
+      local_scalar_t__ ma = DUMMY_VAR__;
+      current_statement__ = 5;
+      ma = context__.vals_r("ma")[(1 - 1)];
+      out__.write(ma);
+      local_scalar_t__ phi_beta = DUMMY_VAR__;
+      current_statement__ = 6;
+      phi_beta = context__.vals_r("phi_beta")[(1 - 1)];
+      out__.write_free_lub(0, 1, phi_beta);
+      local_scalar_t__ sigma2 = DUMMY_VAR__;
+      current_statement__ = 7;
+      sigma2 = context__.vals_r("sigma2")[(1 - 1)];
+      out__.write_free_lb(0, sigma2);
+      local_scalar_t__ Intercept = DUMMY_VAR__;
+      current_statement__ = 8;
+      Intercept = context__.vals_r("Intercept")[(1 - 1)];
+      out__.write(Intercept);
+      Eigen::Matrix<local_scalar_t__,-1,1> mean_price =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> mean_price_flat__;
+        current_statement__ = 9;
+        mean_price_flat__ = context__.vals_r("mean_price");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(mean_price, mean_price_flat__[(pos__ - 1)],
+            "assigning variable mean_price", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(mean_price);
+      Eigen::Matrix<local_scalar_t__,-1,1> sigma_price =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> sigma_price_flat__;
+        current_statement__ = 10;
+        sigma_price_flat__ = context__.vals_r("sigma_price");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(sigma_price, sigma_price_flat__[(pos__ - 1)],
+            "assigning variable sigma_price", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write_free_lb(0.0, sigma_price);
+      local_scalar_t__ theta = DUMMY_VAR__;
+      current_statement__ = 11;
+      theta = context__.vals_r("theta")[(1 - 1)];
+      out__.write(theta);
+      Eigen::Matrix<local_scalar_t__,-1,1> upper_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> upper_test_flat__;
+        current_statement__ = 12;
+        upper_test_flat__ = context__.vals_r("upper_test");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(upper_test, upper_test_flat__[(pos__ - 1)],
+            "assigning variable upper_test", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write_free_ub(ma, upper_test);
+      Eigen::Matrix<local_scalar_t__,-1,1> lower_upper_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> lower_upper_test_flat__;
+        current_statement__ = 13;
+        lower_upper_test_flat__ = context__.vals_r("lower_upper_test");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(lower_upper_test,
+            lower_upper_test_flat__[(pos__ - 1)],
+            "assigning variable lower_upper_test",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write_free_lub(sigma_price, upper_test, lower_upper_test);
+      Eigen::Matrix<local_scalar_t__,1,-1> row_vec_lower_upper_test =
+        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> row_vec_lower_upper_test_flat__;
+        current_statement__ = 14;
+        row_vec_lower_upper_test_flat__ = context__.vals_r("row_vec_lower_upper_test");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(row_vec_lower_upper_test,
+            row_vec_lower_upper_test_flat__[(pos__ - 1)],
+            "assigning variable row_vec_lower_upper_test",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write_free_lub(stan::math::transpose(sigma_price),
+        stan::math::transpose(upper_test), row_vec_lower_upper_test);
+      Eigen::Matrix<local_scalar_t__,-1,1> offset_mult_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> offset_mult_test_flat__;
+        current_statement__ = 15;
+        offset_mult_test_flat__ = context__.vals_r("offset_mult_test");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(offset_mult_test,
+            offset_mult_test_flat__[(pos__ - 1)],
+            "assigning variable offset_mult_test",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write_free_offset_multiplier(mean_price, sigma_price,
+        offset_mult_test);
+      Eigen::Matrix<local_scalar_t__,-1,1> ordered_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> ordered_test_flat__;
+        current_statement__ = 16;
+        ordered_test_flat__ = context__.vals_r("ordered_test");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(ordered_test, ordered_test_flat__[(pos__ - 1)],
+            "assigning variable ordered_test", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write_free_ordered(ordered_test);
+      Eigen::Matrix<local_scalar_t__,-1,1> unit_vec_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> unit_vec_test_flat__;
+        current_statement__ = 17;
+        unit_vec_test_flat__ = context__.vals_r("unit_vec_test");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(unit_vec_test, unit_vec_test_flat__[(pos__ -
+            1)], "assigning variable unit_vec_test",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write_free_unit_vector(unit_vec_test);
+      Eigen::Matrix<local_scalar_t__,-1,1> pos_ordered_test =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> pos_ordered_test_flat__;
+        current_statement__ = 18;
+        pos_ordered_test_flat__ = context__.vals_r("pos_ordered_test");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(pos_ordered_test,
+            pos_ordered_test_flat__[(pos__ - 1)],
+            "assigning variable pos_ordered_test",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write_free_positive_ordered(pos_ordered_test);
+      Eigen::Matrix<local_scalar_t__,-1,-1> corr_matrix_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> corr_matrix_test_flat__;
+        current_statement__ = 19;
+        corr_matrix_test_flat__ = context__.vals_r("corr_matrix_test");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(corr_matrix_test,
+              corr_matrix_test_flat__[(pos__ - 1)],
+              "assigning variable corr_matrix_test",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write_free_corr_matrix(corr_matrix_test);
+      Eigen::Matrix<local_scalar_t__,-1,-1> cov_matrix_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> cov_matrix_test_flat__;
+        current_statement__ = 20;
+        cov_matrix_test_flat__ = context__.vals_r("cov_matrix_test");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(cov_matrix_test,
+              cov_matrix_test_flat__[(pos__ - 1)],
+              "assigning variable cov_matrix_test",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write_free_cov_matrix(cov_matrix_test);
+      Eigen::Matrix<local_scalar_t__,-1,-1> chol_fac_cov_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(K, K, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> chol_fac_cov_test_flat__;
+        current_statement__ = 21;
+        chol_fac_cov_test_flat__ = context__.vals_r("chol_fac_cov_test");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= K; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= K; ++sym2__) {
+            stan::model::assign(chol_fac_cov_test,
+              chol_fac_cov_test_flat__[(pos__ - 1)],
+              "assigning variable chol_fac_cov_test",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write_free_cholesky_factor_cov(chol_fac_cov_test);
+      Eigen::Matrix<local_scalar_t__,-1,-1> chol_fac_corr_test =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(K, K, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> chol_fac_corr_test_flat__;
+        current_statement__ = 22;
+        chol_fac_corr_test_flat__ = context__.vals_r("chol_fac_corr_test");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= K; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= K; ++sym2__) {
+            stan::model::assign(chol_fac_corr_test,
+              chol_fac_corr_test_flat__[(pos__ - 1)],
+              "assigning variable chol_fac_corr_test",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write_free_cholesky_factor_corr(chol_fac_corr_test);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  inline void
+  get_param_names(std::vector<std::string>& names__, const bool
+                  emit_transformed_parameters__ = true, const bool
+                  emit_generated_quantities__ = true) const {
+    names__ = std::vector<std::string>{"high_low_est", "b", "h", "ar", "ma",
+                "phi_beta", "sigma2", "Intercept", "mean_price",
+                "sigma_price", "theta", "upper_test", "lower_upper_test",
+                "row_vec_lower_upper_test", "offset_mult_test",
+                "ordered_test", "unit_vec_test", "pos_ordered_test",
+                "corr_matrix_test", "cov_matrix_test", "chol_fac_cov_test",
+                "chol_fac_corr_test"};
+    if (emit_transformed_parameters__) {
+      std::vector<std::string>
+        temp{"phi", "sigma", "prices", "prices_diff", "mu", "err",
+             "h_i_mean", "h_i_sigma", "h_sigma"};
+      names__.reserve(names__.size() + temp.size());
+      names__.insert(names__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  get_dims(std::vector<std::vector<size_t>>& dimss__, const bool
+           emit_transformed_parameters__ = true, const bool
+           emit_generated_quantities__ = true) const {
+    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{static_cast<
+                                                                    size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(K)},
+                std::vector<size_t>{static_cast<size_t>(Nr)},
+                std::vector<size_t>{static_cast<size_t>(2)},
+                std::vector<size_t>{}, std::vector<size_t>{},
+                std::vector<size_t>{}, std::vector<size_t>{},
+                std::vector<size_t>{static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N)},
+                std::vector<size_t>{},
+                std::vector<size_t>{static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N),
+                  static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N),
+                  static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(K),
+                  static_cast<size_t>(K)},
+                std::vector<size_t>{static_cast<size_t>(K),
+                  static_cast<size_t>(K)}};
+    if (emit_transformed_parameters__) {
+      std::vector<std::vector<size_t>>
+        temp{std::vector<size_t>{}, std::vector<size_t>{},
+             std::vector<size_t>{static_cast<size_t>(N)},
+             std::vector<size_t>{static_cast<size_t>(Nr)},
+             std::vector<size_t>{static_cast<size_t>(Nr)},
+             std::vector<size_t>{static_cast<size_t>(Nr)},
+             std::vector<size_t>{static_cast<size_t>(Nr)},
+             std::vector<size_t>{static_cast<size_t>(Nr)},
+             std::vector<size_t>{static_cast<size_t>(Nr)}};
+      dimss__.reserve(dimss__.size() + temp.size());
+      dimss__.insert(dimss__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  constrained_param_names(std::vector<std::string>& param_names__, bool
+                          emit_transformed_parameters__ = true, bool
+                          emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "high_low_est" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= K; ++sym1__) {
+      param_names__.emplace_back(std::string() + "b" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+      param_names__.emplace_back(std::string() + "h" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= 2; ++sym1__) {
+      param_names__.emplace_back(std::string() + "ar" + '.' +
+        std::to_string(sym1__));
+    }
+    param_names__.emplace_back(std::string() + "ma");
+    param_names__.emplace_back(std::string() + "phi_beta");
+    param_names__.emplace_back(std::string() + "sigma2");
+    param_names__.emplace_back(std::string() + "Intercept");
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "mean_price" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "sigma_price" + '.' +
+        std::to_string(sym1__));
+    }
+    param_names__.emplace_back(std::string() + "theta");
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "upper_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "lower_upper_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "row_vec_lower_upper_test" +
+        '.' + std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "offset_mult_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "ordered_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "unit_vec_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "pos_ordered_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() + "corr_matrix_test" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() + "cov_matrix_test" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= K; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= K; ++sym2__) {
+        param_names__.emplace_back(std::string() + "chol_fac_cov_test" + '.'
+          + std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= K; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= K; ++sym2__) {
+        param_names__.emplace_back(std::string() + "chol_fac_corr_test" + '.'
+          + std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      param_names__.emplace_back(std::string() + "phi");
+      param_names__.emplace_back(std::string() + "sigma");
+      for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+        param_names__.emplace_back(std::string() + "prices" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+        param_names__.emplace_back(std::string() + "prices_diff" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+        param_names__.emplace_back(std::string() + "mu" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+        param_names__.emplace_back(std::string() + "err" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+        param_names__.emplace_back(std::string() + "h_i_mean" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+        param_names__.emplace_back(std::string() + "h_i_sigma" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+        param_names__.emplace_back(std::string() + "h_sigma" + '.' +
+          std::to_string(sym1__));
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  unconstrained_param_names(std::vector<std::string>& param_names__, bool
+                            emit_transformed_parameters__ = true, bool
+                            emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "high_low_est" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= K; ++sym1__) {
+      param_names__.emplace_back(std::string() + "b" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+      param_names__.emplace_back(std::string() + "h" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= 2; ++sym1__) {
+      param_names__.emplace_back(std::string() + "ar" + '.' +
+        std::to_string(sym1__));
+    }
+    param_names__.emplace_back(std::string() + "ma");
+    param_names__.emplace_back(std::string() + "phi_beta");
+    param_names__.emplace_back(std::string() + "sigma2");
+    param_names__.emplace_back(std::string() + "Intercept");
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "mean_price" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "sigma_price" + '.' +
+        std::to_string(sym1__));
+    }
+    param_names__.emplace_back(std::string() + "theta");
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "upper_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "lower_upper_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "row_vec_lower_upper_test" +
+        '.' + std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "offset_mult_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "ordered_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "unit_vec_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "pos_ordered_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= ((N * (N - 1)) / 2); ++sym1__) {
+      param_names__.emplace_back(std::string() + "corr_matrix_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= (N + ((N * (N - 1)) / 2)); ++sym1__) {
+      param_names__.emplace_back(std::string() + "cov_matrix_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= ((((K * (K - 1)) / 2) + K) + ((K - K) *
+         K)); ++sym1__) {
+      param_names__.emplace_back(std::string() + "chol_fac_cov_test" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= ((K * (K - 1)) / 2); ++sym1__) {
+      param_names__.emplace_back(std::string() + "chol_fac_corr_test" + '.' +
+        std::to_string(sym1__));
+    }
+    if (emit_transformed_parameters__) {
+      param_names__.emplace_back(std::string() + "phi");
+      param_names__.emplace_back(std::string() + "sigma");
+      for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+        param_names__.emplace_back(std::string() + "prices" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+        param_names__.emplace_back(std::string() + "prices_diff" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+        param_names__.emplace_back(std::string() + "mu" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+        param_names__.emplace_back(std::string() + "err" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+        param_names__.emplace_back(std::string() + "h_i_mean" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+        param_names__.emplace_back(std::string() + "h_i_sigma" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= Nr; ++sym1__) {
+        param_names__.emplace_back(std::string() + "h_sigma" + '.' +
+          std::to_string(sym1__));
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline std::string get_constrained_sizedtypes() const {
+    return std::string("[{\"name\":\"high_low_est\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(K) + "},\"block\":\"parameters\"},{\"name\":\"h\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"parameters\"},{\"name\":\"ar\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(2) + "},\"block\":\"parameters\"},{\"name\":\"ma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi_beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"Intercept\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_price\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"sigma_price\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"lower_upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"row_vec_lower_upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"offset_mult_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"ordered_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"unit_vec_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"pos_ordered_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"corr_matrix_test\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"cov_matrix_test\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"chol_fac_cov_test\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(K) + ",\"cols\":" + std::to_string(K) + "},\"block\":\"parameters\"},{\"name\":\"chol_fac_corr_test\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(K) + ",\"cols\":" + std::to_string(K) + "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"prices\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"transformed_parameters\"},{\"name\":\"prices_diff\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"mu\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"err\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_i_mean\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_i_sigma\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_sigma\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  inline std::string get_unconstrained_sizedtypes() const {
+    return std::string("[{\"name\":\"high_low_est\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(K) + "},\"block\":\"parameters\"},{\"name\":\"h\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"parameters\"},{\"name\":\"ar\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(2) + "},\"block\":\"parameters\"},{\"name\":\"ma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi_beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"Intercept\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_price\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"sigma_price\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"lower_upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"row_vec_lower_upper_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"offset_mult_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"ordered_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"unit_vec_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"pos_ordered_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"corr_matrix_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(((N * (N - 1)) /2)) + "},\"block\":\"parameters\"},{\"name\":\"cov_matrix_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string((N + ((N * (N - 1)) /2))) + "},\"block\":\"parameters\"},{\"name\":\"chol_fac_cov_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(((((K * (K - 1)) / 2) + K) + ((K - K) *K))) + "},\"block\":\"parameters\"},{\"name\":\"chol_fac_corr_test\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(((K * (K - 1)) /2)) + "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"prices\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"transformed_parameters\"},{\"name\":\"prices_diff\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"mu\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"err\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_i_mean\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_i_sigma\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"},{\"name\":\"h_sigma\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(Nr) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  // Begin method overload boilerplate
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, Eigen::Matrix<double,-1,1>& params_r,
+              Eigen::Matrix<double,-1,1>& vars, const bool
+              emit_transformed_parameters = true, const bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (((((((((((((((((((((N + K) + Nr) + 2) + 1) +
+      1) + 1) + 1) + N) + N) + 1) + N) + N) + N) + N) + N) + N) + N) + (N *
+      N)) + (N * N)) + (K * K)) + (K * K));
+    const size_t num_transformed = emit_transformed_parameters * (((((((((1 +
+      1) + N) + Nr) + Nr) + Nr) + Nr) + Nr) + Nr));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    std::vector<int> params_i;
+    vars = Eigen::Matrix<double,-1,1>::Constant(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, std::vector<double>& params_r, std::vector<int>&
+              params_i, std::vector<double>& vars, bool
+              emit_transformed_parameters = true, bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (((((((((((((((((((((N + K) + Nr) + 2) + 1) +
+      1) + 1) + 1) + N) + N) + 1) + N) + N) + N) + N) + N) + N) + N) + (N *
+      N)) + (N * N)) + (K * K)) + (K * K));
+    const size_t num_transformed = emit_transformed_parameters * (((((((((1 +
+      1) + N) + Nr) + Nr) + Nr) + Nr) + Nr) + Nr));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    vars = std::vector<double>(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(Eigen::Matrix<T_,-1,1>& params_r, std::ostream* pstream = nullptr) const {
+    Eigen::Matrix<int,-1,1> params_i;
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(std::vector<T_>& params_r, std::vector<int>& params_i,
+           std::ostream* pstream = nullptr) const {
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context,
+                  Eigen::Matrix<double,-1,1>& params_r, std::ostream*
+                  pstream = nullptr) const final {
+    std::vector<double> params_r_vec(params_r.size());
+    std::vector<int> params_i;
+    transform_inits(context, params_i, params_r_vec, pstream);
+    params_r = Eigen::Map<Eigen::Matrix<double,-1,1>>(params_r_vec.data(),
+                 params_r_vec.size());
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context, std::vector<int>&
+                  params_i, std::vector<double>& vars, std::ostream*
+                  pstream__ = nullptr) const {
+    vars.resize(num_params_r__);
+    transform_inits_impl(context, vars, pstream__);
+  }
+  inline void
+  unconstrain_array(const std::vector<double>& params_constrained,
+                    std::vector<double>& params_unconstrained, std::ostream*
+                    pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = std::vector<double>(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+  inline void
+  unconstrain_array(const Eigen::Matrix<double,-1,1>& params_constrained,
+                    Eigen::Matrix<double,-1,1>& params_unconstrained,
+                    std::ostream* pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = Eigen::Matrix<double,-1,1>::Constant(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+};
+}
+using stan_model = constraints_model_namespace::constraints_model;
+#ifndef USING_R
+// Boilerplate
+stan::model::model_base&
+new_model(stan::io::var_context& data_context, unsigned int seed,
+          std::ostream* msg_stream) {
+  stan_model* m = new stan_model(data_context, seed, msg_stream);
+  return *m;
+}
+stan::math::profile_map& get_stan_profile_data() {
+  return constraints_model_namespace::profiles__;
+}
+#endif
+OpenCL (Line 65) warning: Function on right hand side of assignment is not supported by SoA: h_i_sigma
+  $ ../../../../../../install/default/bin/stanc --use-opencl --print-cpp deep_dependence.stan
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace deep_dependence_model_namespace {
+using stan::model::model_base_crtp;
+using namespace stan::math;
+stan::math::profile_map profiles__;
+static constexpr std::array<const char*, 14> locations_array__ =
+  {" (found before start of program)",
+  " (in 'deep_dependence.stan', line 6, column 4 to column 23)",
+  " (in 'deep_dependence.stan', line 10, column 4 to column 36)",
+  " (in 'deep_dependence.stan', line 11, column 4 to column 38)",
+  " (in 'deep_dependence.stan', line 12, column 4 to column 38)",
+  " (in 'deep_dependence.stan', line 13, column 4 to column 38)",
+  " (in 'deep_dependence.stan', line 14, column 4 to column 38)",
+  " (in 'deep_dependence.stan', line 15, column 4 to column 38)",
+  " (in 'deep_dependence.stan', line 16, column 4 to column 38)",
+  " (in 'deep_dependence.stan', line 19, column 12 to column 43)",
+  " (in 'deep_dependence.stan', line 18, column 23 to line 20, column 9)",
+  " (in 'deep_dependence.stan', line 18, column 8 to line 20, column 9)",
+  " (in 'deep_dependence.stan', line 17, column 19 to line 21, column 5)",
+  " (in 'deep_dependence.stan', line 17, column 4 to line 21, column 5)"};
+class deep_dependence_model final : public model_base_crtp<deep_dependence_model> {
+ private:
+  
+ public:
+  ~deep_dependence_model() {}
+  deep_dependence_model(stan::io::var_context& context__, unsigned int
+                        random_seed__ = 0, std::ostream* pstream__ = nullptr)
+      : model_base_crtp(0) {
+    int current_statement__ = 0;
+    using local_scalar_t__ = double;
+    boost::ecuyer1988 base_rng__ =
+      stan::services::util::create_rng(random_seed__, 0);
+    // suppress unused var warning
+    (void) base_rng__;
+    static constexpr const char* function__ =
+      "deep_dependence_model_namespace::deep_dependence_model";
+    // suppress unused var warning
+    (void) function__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    num_params_r__ = (10 * 10);
+  }
+  inline std::string model_name() const final {
+    return "deep_dependence_model";
+  }
+  inline std::vector<std::string> model_compile_info() const noexcept {
+    return std::vector<std::string>{"stanc_version = %%NAME%%3 %%VERSION%%",
+             "stancflags = --use-opencl --print-cpp"};
+  }
+  // Base log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_not_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "deep_dependence_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      X_p = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp1 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      stan::model::assign(X_tp1, stan::math::exp(X_p),
+        "assigning variable X_tp1");
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp2 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 3;
+      stan::model::assign(X_tp2, stan::math::exp(X_tp1),
+        "assigning variable X_tp2");
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp3 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 4;
+      stan::model::assign(X_tp3, stan::math::exp(X_tp2),
+        "assigning variable X_tp3");
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp4 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 5;
+      stan::model::assign(X_tp4, stan::math::exp(X_tp3),
+        "assigning variable X_tp4");
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp5 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 6;
+      stan::model::assign(X_tp5, stan::math::exp(X_tp4),
+        "assigning variable X_tp5");
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp6 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 7;
+      stan::model::assign(X_tp6, stan::math::exp(X_tp5),
+        "assigning variable X_tp6");
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp7 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 8;
+      stan::model::assign(X_tp7, stan::math::exp(X_tp6),
+        "assigning variable X_tp7");
+      current_statement__ = 13;
+      for (int i = 1; i <= 5; ++i) {
+        current_statement__ = 11;
+        for (int j = 1; j <= 5; ++j) {
+          current_statement__ = 9;
+          stan::model::assign(X_tp7,
+            stan::math::exp(
+              stan::model::rvalue(X_tp7, "X_tp7", stan::model::index_uni(i),
+                stan::model::index_uni(j))), "assigning variable X_tp7",
+            stan::model::index_uni(i), stan::model::index_uni(j));
+        }
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  // Reverse mode autodiff log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "deep_dependence_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      X_p = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp1 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      stan::model::assign(X_tp1, stan::math::exp(X_p),
+        "assigning variable X_tp1");
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp2 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 3;
+      stan::model::assign(X_tp2, stan::math::exp(X_tp1),
+        "assigning variable X_tp2");
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp3 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 4;
+      stan::model::assign(X_tp3, stan::math::exp(X_tp2),
+        "assigning variable X_tp3");
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp4 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 5;
+      stan::model::assign(X_tp4, stan::math::exp(X_tp3),
+        "assigning variable X_tp4");
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp5 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 6;
+      stan::model::assign(X_tp5, stan::math::exp(X_tp4),
+        "assigning variable X_tp5");
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp6 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 7;
+      stan::model::assign(X_tp6, stan::math::exp(X_tp5),
+        "assigning variable X_tp6");
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_tp7 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 8;
+      stan::model::assign(X_tp7, stan::math::exp(X_tp6),
+        "assigning variable X_tp7");
+      current_statement__ = 13;
+      for (int i = 1; i <= 5; ++i) {
+        current_statement__ = 11;
+        for (int j = 1; j <= 5; ++j) {
+          current_statement__ = 9;
+          stan::model::assign(X_tp7,
+            stan::math::exp(
+              stan::model::rvalue(X_tp7, "X_tp7", stan::model::index_uni(i),
+                stan::model::index_uni(j))), "assigning variable X_tp7",
+            stan::model::index_uni(i), stan::model::index_uni(j));
+        }
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  template <typename RNG, typename VecR, typename VecI, typename VecVar,
+            stan::require_vector_like_vt<std::is_floating_point,
+            VecR>* = nullptr, stan::require_vector_like_vt<std::is_integral,
+            VecI>* = nullptr, stan::require_vector_vt<std::is_floating_point,
+            VecVar>* = nullptr>
+  inline void
+  write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__,
+                   VecVar& vars__, const bool
+                   emit_transformed_parameters__ = true, const bool
+                   emit_generated_quantities__ = true, std::ostream*
+                   pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    static constexpr bool propto__ = true;
+    // suppress unused var warning
+    (void) propto__;
+    double lp__ = 0.0;
+    // suppress unused var warning
+    (void) lp__;
+    int current_statement__ = 0;
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    constexpr bool jacobian__ = false;
+    // suppress unused var warning
+    (void) jacobian__;
+    static constexpr const char* function__ =
+      "deep_dependence_model_namespace::write_array";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<double,-1,-1> X_p =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 1;
+      X_p = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10);
+      Eigen::Matrix<double,-1,-1> X_tp1 =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,-1> X_tp2 =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,-1> X_tp3 =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,-1> X_tp4 =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,-1> X_tp5 =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,-1> X_tp6 =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,-1> X_tp7 =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      out__.write(X_p);
+      if (stan::math::logical_negation(
+            (stan::math::primitive_value(emit_transformed_parameters__) ||
+            stan::math::primitive_value(emit_generated_quantities__)))) {
+        return ;
+      }
+      current_statement__ = 2;
+      stan::model::assign(X_tp1, stan::math::exp(X_p),
+        "assigning variable X_tp1");
+      current_statement__ = 3;
+      stan::model::assign(X_tp2, stan::math::exp(X_tp1),
+        "assigning variable X_tp2");
+      current_statement__ = 4;
+      stan::model::assign(X_tp3, stan::math::exp(X_tp2),
+        "assigning variable X_tp3");
+      current_statement__ = 5;
+      stan::model::assign(X_tp4, stan::math::exp(X_tp3),
+        "assigning variable X_tp4");
+      current_statement__ = 6;
+      stan::model::assign(X_tp5, stan::math::exp(X_tp4),
+        "assigning variable X_tp5");
+      current_statement__ = 7;
+      stan::model::assign(X_tp6, stan::math::exp(X_tp5),
+        "assigning variable X_tp6");
+      current_statement__ = 8;
+      stan::model::assign(X_tp7, stan::math::exp(X_tp6),
+        "assigning variable X_tp7");
+      current_statement__ = 13;
+      for (int i = 1; i <= 5; ++i) {
+        current_statement__ = 11;
+        for (int j = 1; j <= 5; ++j) {
+          current_statement__ = 9;
+          stan::model::assign(X_tp7,
+            stan::math::exp(
+              stan::model::rvalue(X_tp7, "X_tp7", stan::model::index_uni(i),
+                stan::model::index_uni(j))), "assigning variable X_tp7",
+            stan::model::index_uni(i), stan::model::index_uni(j));
+        }
+      }
+      if (emit_transformed_parameters__) {
+        out__.write(X_tp1);
+        out__.write(X_tp2);
+        out__.write(X_tp3);
+        out__.write(X_tp4);
+        out__.write(X_tp5);
+        out__.write(X_tp6);
+        out__.write(X_tp7);
+      }
+      if (stan::math::logical_negation(emit_generated_quantities__)) {
+        return ;
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, typename VecI,
+            stan::require_vector_t<VecVar>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr>
+  inline void
+  unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__,
+                         VecVar& vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      stan::model::assign(X_p,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10),
+        "assigning variable X_p");
+      out__.write(X_p);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, stan::require_vector_t<VecVar>* = nullptr>
+  inline void
+  transform_inits_impl(const stan::io::var_context& context__, VecVar&
+                       vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 1;
+      context__.validate_dims("parameter initialization", "X_p", "double",
+        std::vector<size_t>{static_cast<size_t>(10), static_cast<size_t>(10)});
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      Eigen::Matrix<local_scalar_t__,-1,-1> X_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> X_p_flat__;
+        current_statement__ = 1;
+        X_p_flat__ = context__.vals_r("X_p");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+            stan::model::assign(X_p, X_p_flat__[(pos__ - 1)],
+              "assigning variable X_p", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(X_p);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  inline void
+  get_param_names(std::vector<std::string>& names__, const bool
+                  emit_transformed_parameters__ = true, const bool
+                  emit_generated_quantities__ = true) const {
+    names__ = std::vector<std::string>{"X_p"};
+    if (emit_transformed_parameters__) {
+      std::vector<std::string>
+        temp{"X_tp1", "X_tp2", "X_tp3", "X_tp4", "X_tp5", "X_tp6", "X_tp7"};
+      names__.reserve(names__.size() + temp.size());
+      names__.insert(names__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  get_dims(std::vector<std::vector<size_t>>& dimss__, const bool
+           emit_transformed_parameters__ = true, const bool
+           emit_generated_quantities__ = true) const {
+    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{static_cast<
+                                                                    size_t>(
+                                                                    10),
+                                                 static_cast<size_t>(10)}};
+    if (emit_transformed_parameters__) {
+      std::vector<std::vector<size_t>>
+        temp{std::vector<size_t>{static_cast<size_t>(10),
+               static_cast<size_t>(10)},
+             std::vector<size_t>{static_cast<size_t>(10),
+               static_cast<size_t>(10)},
+             std::vector<size_t>{static_cast<size_t>(10),
+               static_cast<size_t>(10)},
+             std::vector<size_t>{static_cast<size_t>(10),
+               static_cast<size_t>(10)},
+             std::vector<size_t>{static_cast<size_t>(10),
+               static_cast<size_t>(10)},
+             std::vector<size_t>{static_cast<size_t>(10),
+               static_cast<size_t>(10)},
+             std::vector<size_t>{static_cast<size_t>(10),
+               static_cast<size_t>(10)}};
+      dimss__.reserve(dimss__.size() + temp.size());
+      dimss__.insert(dimss__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  constrained_param_names(std::vector<std::string>& param_names__, bool
+                          emit_transformed_parameters__ = true, bool
+                          emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "X_p" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp1" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp2" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp3" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp4" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp5" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp6" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp7" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  unconstrained_param_names(std::vector<std::string>& param_names__, bool
+                            emit_transformed_parameters__ = true, bool
+                            emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "X_p" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp1" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp2" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp3" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp4" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp5" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp6" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "X_tp7" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline std::string get_constrained_sizedtypes() const {
+    return std::string("[{\"name\":\"X_p\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"X_tp1\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"X_tp2\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"X_tp3\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"X_tp4\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"X_tp5\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"X_tp6\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"X_tp7\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  inline std::string get_unconstrained_sizedtypes() const {
+    return std::string("[{\"name\":\"X_p\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"X_tp1\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"X_tp2\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"X_tp3\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"X_tp4\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"X_tp5\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"X_tp6\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"X_tp7\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  // Begin method overload boilerplate
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, Eigen::Matrix<double,-1,1>& params_r,
+              Eigen::Matrix<double,-1,1>& vars, const bool
+              emit_transformed_parameters = true, const bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (10 * 10);
+    const size_t num_transformed = emit_transformed_parameters * ((((((((10 *
+      10) + (10 * 10)) + (10 * 10)) + (10 * 10)) + (10 * 10)) + (10 * 10)) +
+      (10 * 10)));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    std::vector<int> params_i;
+    vars = Eigen::Matrix<double,-1,1>::Constant(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, std::vector<double>& params_r, std::vector<int>&
+              params_i, std::vector<double>& vars, bool
+              emit_transformed_parameters = true, bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (10 * 10);
+    const size_t num_transformed = emit_transformed_parameters * ((((((((10 *
+      10) + (10 * 10)) + (10 * 10)) + (10 * 10)) + (10 * 10)) + (10 * 10)) +
+      (10 * 10)));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    vars = std::vector<double>(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(Eigen::Matrix<T_,-1,1>& params_r, std::ostream* pstream = nullptr) const {
+    Eigen::Matrix<int,-1,1> params_i;
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(std::vector<T_>& params_r, std::vector<int>& params_i,
+           std::ostream* pstream = nullptr) const {
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context,
+                  Eigen::Matrix<double,-1,1>& params_r, std::ostream*
+                  pstream = nullptr) const final {
+    std::vector<double> params_r_vec(params_r.size());
+    std::vector<int> params_i;
+    transform_inits(context, params_i, params_r_vec, pstream);
+    params_r = Eigen::Map<Eigen::Matrix<double,-1,1>>(params_r_vec.data(),
+                 params_r_vec.size());
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context, std::vector<int>&
+                  params_i, std::vector<double>& vars, std::ostream*
+                  pstream__ = nullptr) const {
+    vars.resize(num_params_r__);
+    transform_inits_impl(context, vars, pstream__);
+  }
+  inline void
+  unconstrain_array(const std::vector<double>& params_constrained,
+                    std::vector<double>& params_unconstrained, std::ostream*
+                    pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = std::vector<double>(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+  inline void
+  unconstrain_array(const Eigen::Matrix<double,-1,1>& params_constrained,
+                    Eigen::Matrix<double,-1,1>& params_unconstrained,
+                    std::ostream* pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = Eigen::Matrix<double,-1,1>::Constant(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+};
+}
+using stan_model = deep_dependence_model_namespace::deep_dependence_model;
+#ifndef USING_R
+// Boilerplate
+stan::model::model_base&
+new_model(stan::io::var_context& data_context, unsigned int seed,
+          std::ostream* msg_stream) {
+  stan_model* m = new stan_model(data_context, seed, msg_stream);
+  return *m;
+}
+stan::math::profile_map& get_stan_profile_data() {
+  return deep_dependence_model_namespace::profiles__;
+}
+#endif
+OpenCL (Line 19) warning: Accessed by element in a for loop: X_tp7
+  $ ../../../../../../install/default/bin/stanc --use-opencl --print-cpp indexing.stan
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace indexing_model_namespace {
+using stan::model::model_base_crtp;
+using namespace stan::math;
+stan::math::profile_map profiles__;
+static constexpr std::array<const char*, 116> locations_array__ =
+  {" (found before start of program)",
+  " (in 'indexing.stan', line 19, column 2 to column 13)",
+  " (in 'indexing.stan', line 21, column 2 to column 24)",
+  " (in 'indexing.stan', line 22, column 2 to column 25)",
+  " (in 'indexing.stan', line 23, column 2 to column 38)",
+  " (in 'indexing.stan', line 24, column 2 to column 36)",
+  " (in 'indexing.stan', line 25, column 2 to column 30)",
+  " (in 'indexing.stan', line 26, column 2 to column 41)",
+  " (in 'indexing.stan', line 27, column 2 to column 35)",
+  " (in 'indexing.stan', line 28, column 2 to column 31)",
+  " (in 'indexing.stan', line 29, column 2 to column 48)",
+  " (in 'indexing.stan', line 30, column 2 to column 47)",
+  " (in 'indexing.stan', line 33, column 2 to column 38)",
+  " (in 'indexing.stan', line 35, column 2 to column 38)",
+  " (in 'indexing.stan', line 37, column 2 to column 37)",
+  " (in 'indexing.stan', line 39, column 2 to column 43)",
+  " (in 'indexing.stan', line 40, column 2 to column 41)",
+  " (in 'indexing.stan', line 43, column 2 to column 25)",
+  " (in 'indexing.stan', line 45, column 2 to column 57)",
+  " (in 'indexing.stan', line 46, column 2 to column 57)",
+  " (in 'indexing.stan', line 49, column 2 to column 43)",
+  " (in 'indexing.stan', line 50, column 2 to column 43)",
+  " (in 'indexing.stan', line 56, column 2 to column 41)",
+  " (in 'indexing.stan', line 59, column 2 to column 62)",
+  " (in 'indexing.stan', line 61, column 2 to column 37)",
+  " (in 'indexing.stan', line 66, column 2 to column 63)",
+  " (in 'indexing.stan', line 70, column 2 to column 44)",
+  " (in 'indexing.stan', line 62, column 2 to column 49)",
+  " (in 'indexing.stan', line 63, column 2 to column 70)",
+  " (in 'indexing.stan', line 68, column 2 to column 45)",
+  " (in 'indexing.stan', line 71, column 2 to column 75)",
+  " (in 'indexing.stan', line 75, column 9 to column 10)",
+  " (in 'indexing.stan', line 75, column 2 to column 108)",
+  " (in 'indexing.stan', line 76, column 2 to column 95)",
+  " (in 'indexing.stan', line 77, column 2 to column 56)",
+  " (in 'indexing.stan', line 78, column 2 to column 62)",
+  " (in 'indexing.stan', line 79, column 2 to column 79)",
+  " (in 'indexing.stan', line 80, column 2 to column 85)",
+  " (in 'indexing.stan', line 81, column 2 to column 89)",
+  " (in 'indexing.stan', line 82, column 2 to column 98)",
+  " (in 'indexing.stan', line 83, column 2 to column 110)",
+  " (in 'indexing.stan', line 86, column 9 to column 10)",
+  " (in 'indexing.stan', line 86, column 2 to column 33)",
+  " (in 'indexing.stan', line 87, column 2 to column 32)",
+  " (in 'indexing.stan', line 88, column 9 to column 10)",
+  " (in 'indexing.stan', line 88, column 2 to column 42)",
+  " (in 'indexing.stan', line 89, column 2 to column 86)",
+  " (in 'indexing.stan', line 93, column 4 to column 57)",
+  " (in 'indexing.stan', line 94, column 4 to column 69)",
+  " (in 'indexing.stan', line 95, column 4 to column 69)",
+  " (in 'indexing.stan', line 96, column 4 to column 70)",
+  " (in 'indexing.stan', line 97, column 4 to column 73)",
+  " (in 'indexing.stan', line 98, column 4 to column 69)",
+  " (in 'indexing.stan', line 99, column 4 to column 88)",
+  " (in 'indexing.stan', line 100, column 4 to line 101, column 82)",
+  " (in 'indexing.stan', line 102, column 4 to line 103, column 46)",
+  " (in 'indexing.stan', line 92, column 18 to line 104, column 3)",
+  " (in 'indexing.stan', line 92, column 2 to line 104, column 3)",
+  " (in 'indexing.stan', line 107, column 9 to column 10)",
+  " (in 'indexing.stan', line 107, column 2 to column 38)",
+  " (in 'indexing.stan', line 108, column 9 to column 10)",
+  " (in 'indexing.stan', line 108, column 2 to column 44)",
+  " (in 'indexing.stan', line 111, column 4 to column 84)",
+  " (in 'indexing.stan', line 112, column 4 to column 102)",
+  " (in 'indexing.stan', line 114, column 4 to column 70)",
+  " (in 'indexing.stan', line 115, column 4 to column 75)",
+  " (in 'indexing.stan', line 116, column 4 to line 117, column 40)",
+  " (in 'indexing.stan', line 109, column 17 to line 119, column 3)",
+  " (in 'indexing.stan', line 109, column 2 to line 119, column 3)",
+  " (in 'indexing.stan', line 11, column 1 to column 7)",
+  " (in 'indexing.stan', line 12, column 1 to column 7)",
+  " (in 'indexing.stan', line 13, column 8 to column 9)",
+  " (in 'indexing.stan', line 13, column 11 to column 12)",
+  " (in 'indexing.stan', line 13, column 1 to column 20)",
+  " (in 'indexing.stan', line 14, column 8 to column 9)",
+  " (in 'indexing.stan', line 14, column 1 to column 13)",
+  " (in 'indexing.stan', line 15, column 7 to column 8)",
+  " (in 'indexing.stan', line 15, column 1 to column 25)",
+  " (in 'indexing.stan', line 21, column 9 to column 10)",
+  " (in 'indexing.stan', line 22, column 9 to column 10)",
+  " (in 'indexing.stan', line 22, column 12 to column 13)",
+  " (in 'indexing.stan', line 23, column 19 to column 20)",
+  " (in 'indexing.stan', line 24, column 9 to column 10)",
+  " (in 'indexing.stan', line 24, column 11 to column 12)",
+  " (in 'indexing.stan', line 25, column 9 to column 10)",
+  " (in 'indexing.stan', line 26, column 9 to column 10)",
+  " (in 'indexing.stan', line 26, column 11 to column 12)",
+  " (in 'indexing.stan', line 27, column 13 to column 14)",
+  " (in 'indexing.stan', line 28, column 9 to column 10)",
+  " (in 'indexing.stan', line 29, column 9 to column 10)",
+  " (in 'indexing.stan', line 30, column 9 to column 10)",
+  " (in 'indexing.stan', line 30, column 11 to column 12)",
+  " (in 'indexing.stan', line 33, column 9 to column 10)",
+  " (in 'indexing.stan', line 35, column 9 to column 10)",
+  " (in 'indexing.stan', line 37, column 9 to column 10)",
+  " (in 'indexing.stan', line 39, column 9 to column 10)",
+  " (in 'indexing.stan', line 40, column 9 to column 10)",
+  " (in 'indexing.stan', line 40, column 11 to column 12)",
+  " (in 'indexing.stan', line 43, column 9 to column 10)",
+  " (in 'indexing.stan', line 43, column 12 to column 13)",
+  " (in 'indexing.stan', line 45, column 9 to column 10)",
+  " (in 'indexing.stan', line 45, column 12 to column 13)",
+  " (in 'indexing.stan', line 46, column 9 to column 10)",
+  " (in 'indexing.stan', line 46, column 12 to column 13)",
+  " (in 'indexing.stan', line 49, column 9 to column 10)",
+  " (in 'indexing.stan', line 49, column 12 to column 13)",
+  " (in 'indexing.stan', line 50, column 9 to column 10)",
+  " (in 'indexing.stan', line 50, column 12 to column 13)",
+  " (in 'indexing.stan', line 59, column 9 to column 10)",
+  " (in 'indexing.stan', line 61, column 9 to column 10)",
+  " (in 'indexing.stan', line 66, column 9 to column 10)",
+  " (in 'indexing.stan', line 70, column 9 to column 10)",
+  " (in 'indexing.stan', line 3, column 4 to column 13)",
+  " (in 'indexing.stan', line 2, column 22 to line 4, column 3)",
+  " (in 'indexing.stan', line 6, column 4 to column 13)",
+  " (in 'indexing.stan', line 5, column 27 to line 7, column 3)"};
+int mask_fun(const int& i, std::ostream* pstream__);
+template <typename T0__,
+          stan::require_all_t<stan::is_col_vector<T0__>,
+                              stan::is_vt_not_complex<T0__>>* = nullptr>
+Eigen::Matrix<stan::promote_args_t<stan::base_type_t<T0__>>,-1,1>
+udf_fun(const T0__& A_arg__, std::ostream* pstream__);
+int mask_fun(const int& i, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  int current_statement__ = 0;
+  static constexpr bool propto__ = true;
+  // suppress unused var warning
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  // suppress unused var warning
+  (void) DUMMY_VAR__;
+  try {
+    current_statement__ = 112;
+    return i;
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+  }
+}
+template <typename T0__,
+          stan::require_all_t<stan::is_col_vector<T0__>,
+                              stan::is_vt_not_complex<T0__>>*>
+Eigen::Matrix<stan::promote_args_t<stan::base_type_t<T0__>>,-1,1>
+udf_fun(const T0__& A_arg__, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<stan::base_type_t<T0__>>;
+  int current_statement__ = 0;
+  const auto& A = stan::math::to_ref(A_arg__);
+  static constexpr bool propto__ = true;
+  // suppress unused var warning
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  // suppress unused var warning
+  (void) DUMMY_VAR__;
+  try {
+    current_statement__ = 114;
+    return A;
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+  }
+}
+class indexing_model final : public model_base_crtp<indexing_model> {
+ private:
+  int N;
+  int M;
+  Eigen::Matrix<double,-1,-1> dat_x_data__;
+  Eigen::Matrix<double,-1,1> y_data__;
+  std::vector<int> idx_tester;
+  Eigen::Map<Eigen::Matrix<double,-1,-1>> dat_x{nullptr, 0, 0};
+  Eigen::Map<Eigen::Matrix<double,-1,1>> y{nullptr, 0};
+ public:
+  ~indexing_model() {}
+  indexing_model(stan::io::var_context& context__, unsigned int
+                 random_seed__ = 0, std::ostream* pstream__ = nullptr)
+      : model_base_crtp(0) {
+    int current_statement__ = 0;
+    using local_scalar_t__ = double;
+    boost::ecuyer1988 base_rng__ =
+      stan::services::util::create_rng(random_seed__, 0);
+    // suppress unused var warning
+    (void) base_rng__;
+    static constexpr const char* function__ =
+      "indexing_model_namespace::indexing_model";
+    // suppress unused var warning
+    (void) function__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      current_statement__ = 69;
+      context__.validate_dims("data initialization", "N", "int",
+        std::vector<size_t>{});
+      N = std::numeric_limits<int>::min();
+      current_statement__ = 69;
+      N = context__.vals_i("N")[(1 - 1)];
+      current_statement__ = 70;
+      context__.validate_dims("data initialization", "M", "int",
+        std::vector<size_t>{});
+      M = std::numeric_limits<int>::min();
+      current_statement__ = 70;
+      M = context__.vals_i("M")[(1 - 1)];
+      current_statement__ = 71;
+      stan::math::validate_non_negative_index("dat_x", "N", N);
+      current_statement__ = 72;
+      stan::math::validate_non_negative_index("dat_x", "M", M);
+      current_statement__ = 73;
+      context__.validate_dims("data initialization", "dat_x", "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(M)});
+      dat_x_data__ = Eigen::Matrix<double,-1,-1>::Constant(N, M,
+                       std::numeric_limits<double>::quiet_NaN());
+      new (&dat_x)
+        Eigen::Map<Eigen::Matrix<double,-1,-1>>(dat_x_data__.data(), N, M);
+      {
+        std::vector<local_scalar_t__> dat_x_flat__;
+        current_statement__ = 73;
+        dat_x_flat__ = context__.vals_r("dat_x");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(dat_x, dat_x_flat__[(pos__ - 1)],
+              "assigning variable dat_x", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      current_statement__ = 74;
+      stan::math::validate_non_negative_index("y", "N", N);
+      current_statement__ = 75;
+      context__.validate_dims("data initialization", "y", "double",
+        std::vector<size_t>{static_cast<size_t>(N)});
+      y_data__ = Eigen::Matrix<double,-1,1>::Constant(N,
+                   std::numeric_limits<double>::quiet_NaN());
+      new (&y) Eigen::Map<Eigen::Matrix<double,-1,1>>(y_data__.data(), N);
+      {
+        std::vector<local_scalar_t__> y_flat__;
+        current_statement__ = 75;
+        y_flat__ = context__.vals_r("y");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(y, y_flat__[(pos__ - 1)],
+            "assigning variable y", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      current_statement__ = 76;
+      stan::math::validate_non_negative_index("idx_tester", "N", N);
+      current_statement__ = 77;
+      context__.validate_dims("data initialization", "idx_tester", "int",
+        std::vector<size_t>{static_cast<size_t>(N)});
+      idx_tester = std::vector<int>(N, std::numeric_limits<int>::min());
+      current_statement__ = 77;
+      idx_tester = context__.vals_i("idx_tester");
+      current_statement__ = 78;
+      stan::math::validate_non_negative_index("p_soa_vec_v", "M", M);
+      current_statement__ = 79;
+      stan::math::validate_non_negative_index("p_soa_mat", "N", N);
+      current_statement__ = 80;
+      stan::math::validate_non_negative_index("p_soa_mat", "M", M);
+      current_statement__ = 81;
+      stan::math::validate_non_negative_index("p_soa_arr_vec_v", "N", N);
+      current_statement__ = 82;
+      stan::math::validate_non_negative_index("p_soa_mat_uni_col_idx", "N", N);
+      current_statement__ = 83;
+      stan::math::validate_non_negative_index("p_soa_mat_uni_col_idx", "M", M);
+      current_statement__ = 84;
+      stan::math::validate_non_negative_index("p_soa_vec_uni_idx", "N", N);
+      current_statement__ = 85;
+      stan::math::validate_non_negative_index("p_soa_loop_mat_uni_col_idx",
+        "N", N);
+      current_statement__ = 86;
+      stan::math::validate_non_negative_index("p_soa_loop_mat_uni_col_idx",
+        "M", M);
+      current_statement__ = 87;
+      stan::math::validate_non_negative_index("p_soa_lhs_loop_mul", "N", N);
+      current_statement__ = 88;
+      stan::math::validate_non_negative_index("p_soa_rhs_loop_mul", "N", N);
+      current_statement__ = 89;
+      stan::math::validate_non_negative_index(
+        "p_soa_used_with_aos_in_excluded_fun", "N", N);
+      current_statement__ = 90;
+      stan::math::validate_non_negative_index(
+        "p_soa_loop_mat_multi_uni_uni_idx", "N", N);
+      current_statement__ = 91;
+      stan::math::validate_non_negative_index(
+        "p_soa_loop_mat_multi_uni_uni_idx", "M", M);
+      current_statement__ = 92;
+      stan::math::validate_non_negative_index("p_aos_vec_v_assign_to_aos",
+        "M", M);
+      current_statement__ = 93;
+      stan::math::validate_non_negative_index("p_aos_vec_v_tp_fails_func",
+        "M", M);
+      current_statement__ = 94;
+      stan::math::validate_non_negative_index("p_aos_loop_vec_v_uni_idx",
+        "M", M);
+      current_statement__ = 95;
+      stan::math::validate_non_negative_index(
+        "p_aos_fail_assign_from_top_idx", "M", M);
+      current_statement__ = 96;
+      stan::math::validate_non_negative_index("p_aos_loop_mat_uni_uni_idx",
+        "N", N);
+      current_statement__ = 97;
+      stan::math::validate_non_negative_index("p_aos_loop_mat_uni_uni_idx",
+        "M", M);
+      current_statement__ = 98;
+      stan::math::validate_non_negative_index("p_aos_mat", "N", N);
+      current_statement__ = 99;
+      stan::math::validate_non_negative_index("p_aos_mat", "M", M);
+      current_statement__ = 100;
+      stan::math::validate_non_negative_index(
+        "p_aos_mat_pass_func_outer_single_indexed1", "N", N);
+      current_statement__ = 101;
+      stan::math::validate_non_negative_index(
+        "p_aos_mat_pass_func_outer_single_indexed1", "M", M);
+      current_statement__ = 102;
+      stan::math::validate_non_negative_index(
+        "p_aos_mat_pass_func_outer_single_indexed2", "N", N);
+      current_statement__ = 103;
+      stan::math::validate_non_negative_index(
+        "p_aos_mat_pass_func_outer_single_indexed2", "M", M);
+      current_statement__ = 104;
+      stan::math::validate_non_negative_index("p_aos_mat_fail_uni_uni_idx1",
+        "N", N);
+      current_statement__ = 105;
+      stan::math::validate_non_negative_index("p_aos_mat_fail_uni_uni_idx1",
+        "M", M);
+      current_statement__ = 106;
+      stan::math::validate_non_negative_index("p_aos_mat_fail_uni_uni_idx2",
+        "N", N);
+      current_statement__ = 107;
+      stan::math::validate_non_negative_index("p_aos_mat_fail_uni_uni_idx2",
+        "M", M);
+      current_statement__ = 108;
+      stan::math::validate_non_negative_index("tp_aos_vec_v", "M", M);
+      current_statement__ = 109;
+      stan::math::validate_non_negative_index("tp_soa_single_idx_uninit",
+        "M", M);
+      current_statement__ = 110;
+      stan::math::validate_non_negative_index("tp_aos_fail_func_vec_v", "M",
+        M);
+      current_statement__ = 111;
+      stan::math::validate_non_negative_index(
+        "tp_aos_fail_assign_from_top_idx", "M", M);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    num_params_r__ = 1 + M + (N * M) + (10 * N) + (N * M) + N + (N * M) + N +
+      N + N + (N * M) + M + M + M + M + (N * M) + (N * M) + (N * M) + (N * M)
+      + (N * M) + (N * M);
+  }
+  inline std::string model_name() const final {
+    return "indexing_model";
+  }
+  inline std::vector<std::string> model_compile_info() const noexcept {
+    return std::vector<std::string>{"stanc_version = %%NAME%%3 %%VERSION%%",
+             "stancflags = --use-opencl --print-cpp"};
+  }
+  // Base log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_not_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "indexing_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      local_scalar_t__ alpha = DUMMY_VAR__;
+      current_statement__ = 1;
+      alpha = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<local_scalar_t__,-1,1> p_soa_vec_v =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 2;
+      p_soa_vec_v = in__.template read<
+                      Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_soa_mat =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 3;
+      p_soa_mat = in__.template read<
+                    Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M);
+      std::vector<Eigen::Matrix<local_scalar_t__,-1,1>> p_soa_arr_vec_v =
+        std::vector<Eigen::Matrix<local_scalar_t__,-1,1>>(10,
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__));
+      current_statement__ = 4;
+      p_soa_arr_vec_v = in__.template read<
+                          std::vector<Eigen::Matrix<local_scalar_t__,-1,1>>>(10,
+                          N);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_soa_mat_uni_col_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 5;
+      p_soa_mat_uni_col_idx = in__.template read<
+                                Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_soa_vec_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 6;
+      p_soa_vec_uni_idx = in__.template read<
+                            Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_soa_loop_mat_uni_col_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 7;
+      p_soa_loop_mat_uni_col_idx = in__.template read<
+                                     Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                     M);
+      Eigen::Matrix<local_scalar_t__,1,-1> p_soa_lhs_loop_mul =
+        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 8;
+      p_soa_lhs_loop_mul = in__.template read<
+                             Eigen::Matrix<local_scalar_t__,1,-1>>(N);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_soa_rhs_loop_mul =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 9;
+      p_soa_rhs_loop_mul = in__.template read<
+                             Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      Eigen::Matrix<local_scalar_t__,-1,1>
+        p_soa_used_with_aos_in_excluded_fun =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 10;
+      p_soa_used_with_aos_in_excluded_fun = in__.template read<
+                                              Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      Eigen::Matrix<local_scalar_t__,-1,-1>
+        p_soa_loop_mat_multi_uni_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 11;
+      p_soa_loop_mat_multi_uni_uni_idx = in__.template read<
+                                           Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                           M);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_vec_v_assign_to_aos =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 12;
+      p_aos_vec_v_assign_to_aos = in__.template read<
+                                    Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_vec_v_tp_fails_func =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 13;
+      p_aos_vec_v_tp_fails_func = in__.template read<
+                                    Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_loop_vec_v_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 14;
+      p_aos_loop_vec_v_uni_idx = in__.template read<
+                                   Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_fail_assign_from_top_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 15;
+      p_aos_fail_assign_from_top_idx = in__.template read<
+                                         Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_loop_mat_uni_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 16;
+      p_aos_loop_mat_uni_uni_idx = in__.template read<
+                                     Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                     M);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_mat =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 17;
+      p_aos_mat = in__.template read<
+                    Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M);
+      Eigen::Matrix<local_scalar_t__,-1,-1>
+        p_aos_mat_pass_func_outer_single_indexed1 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 18;
+      p_aos_mat_pass_func_outer_single_indexed1 = in__.template read<
+                                                    Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                                    M);
+      Eigen::Matrix<local_scalar_t__,-1,-1>
+        p_aos_mat_pass_func_outer_single_indexed2 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 19;
+      p_aos_mat_pass_func_outer_single_indexed2 = in__.template read<
+                                                    Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                                    M);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_mat_fail_uni_uni_idx1 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 20;
+      p_aos_mat_fail_uni_uni_idx1 = in__.template read<
+                                      Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                      M);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_mat_fail_uni_uni_idx2 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 21;
+      p_aos_mat_fail_uni_uni_idx2 = in__.template read<
+                                      Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                      M);
+      local_scalar_t__ tp_real_from_aos = DUMMY_VAR__;
+      current_statement__ = 22;
+      tp_real_from_aos = stan::model::rvalue(p_soa_vec_v, "p_soa_vec_v",
+                           stan::model::index_uni(1));
+      Eigen::Matrix<local_scalar_t__,-1,1> tp_aos_vec_v =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 23;
+      stan::model::assign(tp_aos_vec_v,
+        udf_fun(p_aos_vec_v_assign_to_aos, pstream__),
+        "assigning variable tp_aos_vec_v");
+      Eigen::Matrix<local_scalar_t__,-1,1> tp_soa_single_idx_uninit =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 27;
+      stan::model::assign(tp_soa_single_idx_uninit, tp_real_from_aos,
+        "assigning variable tp_soa_single_idx_uninit",
+        stan::model::index_uni(1));
+      current_statement__ = 28;
+      stan::model::assign(tp_soa_single_idx_uninit,
+        stan::math::rep_vector(tp_real_from_aos, (M - 1)),
+        "assigning variable tp_soa_single_idx_uninit",
+        stan::model::index_min_max(2, M));
+      Eigen::Matrix<local_scalar_t__,-1,1> tp_aos_fail_func_vec_v =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 25;
+      stan::model::assign(tp_aos_fail_func_vec_v, p_aos_vec_v_tp_fails_func,
+        "assigning variable tp_aos_fail_func_vec_v");
+      current_statement__ = 29;
+      stan::model::assign(tp_aos_fail_func_vec_v,
+        stan::model::rvalue(p_soa_vec_v, "p_soa_vec_v",
+          stan::model::index_uni(1)),
+        "assigning variable tp_aos_fail_func_vec_v",
+        stan::model::index_uni(1));
+      Eigen::Matrix<local_scalar_t__,-1,1> tp_aos_fail_assign_from_top_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 30;
+      stan::model::assign(tp_aos_fail_assign_from_top_idx,
+        stan::model::rvalue(p_aos_fail_assign_from_top_idx,
+          "p_aos_fail_assign_from_top_idx", stan::model::index_min(1)),
+        "assigning variable tp_aos_fail_assign_from_top_idx",
+        stan::model::index_min(1));
+      {
+        current_statement__ = 31;
+        stan::math::validate_non_negative_index(
+          "tp_soa_used_with_aos_in_excluded_fun", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1>
+          tp_soa_used_with_aos_in_excluded_fun =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 32;
+        stan::model::assign(tp_soa_used_with_aos_in_excluded_fun,
+          stan::math::multiply(p_soa_used_with_aos_in_excluded_fun,
+            stan::math::size(tp_aos_vec_v)),
+          "assigning variable tp_soa_used_with_aos_in_excluded_fun");
+        current_statement__ = 33;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::add(alpha,
+                           stan::math::multiply(dat_x,
+                             stan::math::add(p_soa_vec_v,
+                               tp_soa_used_with_aos_in_excluded_fun))), 1.0));
+        current_statement__ = 34;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::add(alpha,
+                           stan::math::multiply(dat_x, p_soa_vec_v)), 1.0));
+        current_statement__ = 35;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::multiply(dat_x,
+                           stan::model::rvalue(p_soa_mat_uni_col_idx,
+                             "p_soa_mat_uni_col_idx",
+                             stan::model::index_omni(),
+                             stan::model::index_uni(N))), 1.0));
+        current_statement__ = 36;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::multiply(dat_x,
+                           stan::model::rvalue(p_soa_mat_uni_col_idx,
+                             "p_soa_mat_uni_col_idx",
+                             stan::model::index_omni(),
+                             stan::model::index_uni(N))),
+                         stan::model::rvalue(p_soa_vec_uni_idx,
+                           "p_soa_vec_uni_idx", stan::model::index_uni(N))));
+        current_statement__ = 37;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::multiply(dat_x,
+                           udf_fun(tp_aos_fail_func_vec_v, pstream__)),
+                         stan::model::rvalue(p_soa_vec_uni_idx,
+                           "p_soa_vec_uni_idx", stan::model::index_uni(N))));
+        current_statement__ = 38;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::multiply(p_soa_mat,
+                           udf_fun(tp_aos_fail_func_vec_v, pstream__)),
+                         stan::model::rvalue(p_soa_vec_uni_idx,
+                           "p_soa_vec_uni_idx", stan::model::index_uni(N))));
+        current_statement__ = 39;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::multiply(p_soa_mat,
+                           udf_fun(tp_aos_fail_assign_from_top_idx, pstream__)),
+                         stan::model::rvalue(p_soa_vec_uni_idx,
+                           "p_soa_vec_uni_idx", stan::model::index_uni(N))));
+        current_statement__ = 40;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::multiply(p_soa_mat,
+                           udf_fun(
+                             stan::math::multiply(p_aos_mat,
+                               tp_aos_fail_func_vec_v), pstream__)),
+                         stan::model::rvalue(p_soa_vec_uni_idx,
+                           "p_soa_vec_uni_idx", stan::model::index_uni(N))));
+        current_statement__ = 41;
+        stan::math::validate_non_negative_index("tp_soa_single_assign", "N",
+          N);
+        Eigen::Matrix<local_scalar_t__,-1,1> tp_soa_single_assign =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 43;
+        stan::model::assign(tp_soa_single_assign, 2.0,
+          "assigning variable tp_soa_single_assign",
+          stan::model::index_uni(1));
+        current_statement__ = 44;
+        stan::math::validate_non_negative_index(
+          "tp_soa_single_assign_from_soa", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1> tp_soa_single_assign_from_soa =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 46;
+        stan::model::assign(tp_soa_single_assign_from_soa,
+          stan::math::multiply(p_soa_lhs_loop_mul, p_soa_rhs_loop_mul),
+          "assigning variable tp_soa_single_assign_from_soa",
+          stan::model::index_uni(2));
+        current_statement__ = 57;
+        for (int i = 1; i <= 10; ++i) {
+          current_statement__ = 47;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(dat_x,
+                             stan::model::rvalue(p_soa_arr_vec_v,
+                               "p_soa_arr_vec_v", stan::model::index_uni(i))),
+                           1.0));
+          current_statement__ = 48;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(dat_x,
+                             stan::model::rvalue(p_soa_loop_mat_uni_col_idx,
+                               "p_soa_loop_mat_uni_col_idx",
+                               stan::model::index_omni(),
+                               stan::model::index_uni(i))), 1.0));
+          current_statement__ = 49;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(
+                             stan::model::rvalue(p_soa_loop_mat_uni_col_idx,
+                               "p_soa_loop_mat_uni_col_idx",
+                               stan::model::index_uni(i),
+                               stan::model::index_omni()), dat_x), 1.0));
+          current_statement__ = 50;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(dat_x,
+                             stan::math::transpose(
+                               stan::model::rvalue(
+                                 p_soa_loop_mat_uni_col_idx,
+                                 "p_soa_loop_mat_uni_col_idx",
+                                 stan::model::index_uni(i),
+                                 stan::model::index_omni()))), 1.0));
+          current_statement__ = 51;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(dat_x,
+                             stan::model::rvalue(p_soa_loop_mat_uni_col_idx,
+                               "p_soa_loop_mat_uni_col_idx",
+                               stan::model::index_min_max(1, N),
+                               stan::model::index_uni(1))), 1.0));
+          current_statement__ = 52;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(dat_x,
+                             stan::math::transpose(
+                               stan::model::rvalue(
+                                 p_soa_loop_mat_uni_col_idx,
+                                 "p_soa_loop_mat_uni_col_idx",
+                                 stan::model::index_uni(i)))), 1.0));
+          current_statement__ = 53;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(dat_x,
+                             stan::math::transpose(
+                               stan::model::rvalue(
+                                 p_soa_loop_mat_multi_uni_uni_idx,
+                                 "p_soa_loop_mat_multi_uni_uni_idx",
+                                 stan::model::index_uni(
+                                   stan::model::rvalue(idx_tester,
+                                     "idx_tester", stan::model::index_uni(i))),
+                                 stan::model::index_omni()))), 1.0));
+          current_statement__ = 54;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(
+                             stan::model::rvalue(dat_x, "dat_x",
+                               stan::model::index_omni(),
+                               stan::model::index_uni(i)),
+                             stan::model::rvalue(
+                               stan::math::transpose(
+                                 stan::math::multiply(
+                                   p_aos_mat_pass_func_outer_single_indexed1,
+                                   p_aos_mat_pass_func_outer_single_indexed2)),
+                               "transpose(multiply(p_aos_mat_pass_func_outer_single_indexed1,\n                   p_aos_mat_pass_func_outer_single_indexed2))",
+                               stan::model::index_uni(mask_fun(i, pstream__)),
+                               stan::model::index_uni(mask_fun(i, pstream__)))),
+                           1.0));
+          current_statement__ = 55;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(
+                             stan::model::rvalue(dat_x, "dat_x",
+                               stan::model::index_omni(),
+                               stan::model::index_uni(i)),
+                             (stan::model::rvalue(
+                                p_aos_mat_fail_uni_uni_idx1,
+                                "p_aos_mat_fail_uni_uni_idx1",
+                                stan::model::index_uni(i),
+                                stan::model::index_uni(i)) *
+                             stan::model::rvalue(p_aos_mat_fail_uni_uni_idx2,
+                               "p_aos_mat_fail_uni_uni_idx2",
+                               stan::model::index_uni(i),
+                               stan::model::index_uni(i)))), 1.0));
+        }
+        current_statement__ = 58;
+        stan::math::validate_non_negative_index("tp_aos_loop_vec_v_uni_idx",
+          "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1> tp_aos_loop_vec_v_uni_idx =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 60;
+        stan::math::validate_non_negative_index(
+          "tp_aos_loop_vec_v_multi_uni_idx", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1>
+          tp_aos_loop_vec_v_multi_uni_idx =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 68;
+        for (int i = 1; i <= N; ++i) {
+          current_statement__ = 62;
+          stan::model::assign(tp_aos_loop_vec_v_uni_idx,
+            stan::math::multiply(p_soa_lhs_loop_mul, p_soa_rhs_loop_mul),
+            "assigning variable tp_aos_loop_vec_v_uni_idx",
+            stan::model::index_uni(i));
+          current_statement__ = 63;
+          stan::model::assign(tp_aos_loop_vec_v_multi_uni_idx,
+            stan::math::multiply(p_soa_lhs_loop_mul, p_soa_rhs_loop_mul),
+            "assigning variable tp_aos_loop_vec_v_multi_uni_idx",
+            stan::model::index_uni(
+              stan::model::rvalue(idx_tester, "idx_tester",
+                stan::model::index_uni(i))));
+          current_statement__ = 64;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(
+                             stan::model::rvalue(dat_x, "dat_x",
+                               stan::model::index_omni(),
+                               stan::model::index_uni(i)),
+                             stan::model::rvalue(p_aos_loop_vec_v_uni_idx,
+                               "p_aos_loop_vec_v_uni_idx",
+                               stan::model::index_uni(i))), 1.0));
+          current_statement__ = 65;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(
+                             stan::model::rvalue(dat_x, "dat_x",
+                               stan::model::index_omni(),
+                               stan::model::index_uni(i)),
+                             stan::model::rvalue(p_aos_loop_mat_uni_uni_idx,
+                               "p_aos_loop_mat_uni_uni_idx",
+                               stan::model::index_uni(i),
+                               stan::model::index_uni(i))), 1.0));
+          current_statement__ = 66;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::model::rvalue(dat_x, "dat_x",
+                             stan::model::index_omni(),
+                             stan::model::index_uni(i)),
+                           (stan::model::rvalue(p_aos_mat_fail_uni_uni_idx1,
+                              "p_aos_mat_fail_uni_uni_idx1",
+                              stan::model::index_uni(i),
+                              stan::model::index_uni(i)) *
+                           stan::model::rvalue(p_aos_mat_fail_uni_uni_idx2,
+                             "p_aos_mat_fail_uni_uni_idx2",
+                             stan::model::index_uni(i),
+                             stan::model::index_uni(i)))));
+        }
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  // Reverse mode autodiff log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "indexing_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      local_scalar_t__ alpha = DUMMY_VAR__;
+      current_statement__ = 1;
+      alpha = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<local_scalar_t__,-1,1> p_soa_vec_v =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 2;
+      p_soa_vec_v = in__.template read<
+                      Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_soa_mat =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 3;
+      p_soa_mat = in__.template read<
+                    Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M);
+      std::vector<Eigen::Matrix<local_scalar_t__,-1,1>> p_soa_arr_vec_v =
+        std::vector<Eigen::Matrix<local_scalar_t__,-1,1>>(10,
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__));
+      current_statement__ = 4;
+      p_soa_arr_vec_v = in__.template read<
+                          std::vector<Eigen::Matrix<local_scalar_t__,-1,1>>>(10,
+                          N);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_soa_mat_uni_col_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 5;
+      p_soa_mat_uni_col_idx = in__.template read<
+                                Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_soa_vec_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 6;
+      p_soa_vec_uni_idx = in__.template read<
+                            Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_soa_loop_mat_uni_col_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 7;
+      p_soa_loop_mat_uni_col_idx = in__.template read<
+                                     Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                     M);
+      Eigen::Matrix<local_scalar_t__,1,-1> p_soa_lhs_loop_mul =
+        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 8;
+      p_soa_lhs_loop_mul = in__.template read<
+                             Eigen::Matrix<local_scalar_t__,1,-1>>(N);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_soa_rhs_loop_mul =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 9;
+      p_soa_rhs_loop_mul = in__.template read<
+                             Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      Eigen::Matrix<local_scalar_t__,-1,1>
+        p_soa_used_with_aos_in_excluded_fun =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 10;
+      p_soa_used_with_aos_in_excluded_fun = in__.template read<
+                                              Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      Eigen::Matrix<local_scalar_t__,-1,-1>
+        p_soa_loop_mat_multi_uni_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 11;
+      p_soa_loop_mat_multi_uni_uni_idx = in__.template read<
+                                           Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                           M);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_vec_v_assign_to_aos =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 12;
+      p_aos_vec_v_assign_to_aos = in__.template read<
+                                    Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_vec_v_tp_fails_func =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 13;
+      p_aos_vec_v_tp_fails_func = in__.template read<
+                                    Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_loop_vec_v_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 14;
+      p_aos_loop_vec_v_uni_idx = in__.template read<
+                                   Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_fail_assign_from_top_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 15;
+      p_aos_fail_assign_from_top_idx = in__.template read<
+                                         Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_loop_mat_uni_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 16;
+      p_aos_loop_mat_uni_uni_idx = in__.template read<
+                                     Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                     M);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_mat =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 17;
+      p_aos_mat = in__.template read<
+                    Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M);
+      Eigen::Matrix<local_scalar_t__,-1,-1>
+        p_aos_mat_pass_func_outer_single_indexed1 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 18;
+      p_aos_mat_pass_func_outer_single_indexed1 = in__.template read<
+                                                    Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                                    M);
+      Eigen::Matrix<local_scalar_t__,-1,-1>
+        p_aos_mat_pass_func_outer_single_indexed2 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 19;
+      p_aos_mat_pass_func_outer_single_indexed2 = in__.template read<
+                                                    Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                                    M);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_mat_fail_uni_uni_idx1 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 20;
+      p_aos_mat_fail_uni_uni_idx1 = in__.template read<
+                                      Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                      M);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_mat_fail_uni_uni_idx2 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 21;
+      p_aos_mat_fail_uni_uni_idx2 = in__.template read<
+                                      Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                      M);
+      local_scalar_t__ tp_real_from_aos = DUMMY_VAR__;
+      current_statement__ = 22;
+      tp_real_from_aos = stan::model::rvalue(p_soa_vec_v, "p_soa_vec_v",
+                           stan::model::index_uni(1));
+      Eigen::Matrix<local_scalar_t__,-1,1> tp_aos_vec_v =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 23;
+      stan::model::assign(tp_aos_vec_v,
+        udf_fun(p_aos_vec_v_assign_to_aos, pstream__),
+        "assigning variable tp_aos_vec_v");
+      Eigen::Matrix<local_scalar_t__,-1,1> tp_soa_single_idx_uninit =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 27;
+      stan::model::assign(tp_soa_single_idx_uninit, tp_real_from_aos,
+        "assigning variable tp_soa_single_idx_uninit",
+        stan::model::index_uni(1));
+      current_statement__ = 28;
+      stan::model::assign(tp_soa_single_idx_uninit,
+        stan::math::rep_vector(tp_real_from_aos, (M - 1)),
+        "assigning variable tp_soa_single_idx_uninit",
+        stan::model::index_min_max(2, M));
+      Eigen::Matrix<local_scalar_t__,-1,1> tp_aos_fail_func_vec_v =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 25;
+      stan::model::assign(tp_aos_fail_func_vec_v, p_aos_vec_v_tp_fails_func,
+        "assigning variable tp_aos_fail_func_vec_v");
+      current_statement__ = 29;
+      stan::model::assign(tp_aos_fail_func_vec_v,
+        stan::model::rvalue(p_soa_vec_v, "p_soa_vec_v",
+          stan::model::index_uni(1)),
+        "assigning variable tp_aos_fail_func_vec_v",
+        stan::model::index_uni(1));
+      Eigen::Matrix<local_scalar_t__,-1,1> tp_aos_fail_assign_from_top_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 30;
+      stan::model::assign(tp_aos_fail_assign_from_top_idx,
+        stan::model::rvalue(p_aos_fail_assign_from_top_idx,
+          "p_aos_fail_assign_from_top_idx", stan::model::index_min(1)),
+        "assigning variable tp_aos_fail_assign_from_top_idx",
+        stan::model::index_min(1));
+      {
+        current_statement__ = 31;
+        stan::math::validate_non_negative_index(
+          "tp_soa_used_with_aos_in_excluded_fun", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1>
+          tp_soa_used_with_aos_in_excluded_fun =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 32;
+        stan::model::assign(tp_soa_used_with_aos_in_excluded_fun,
+          stan::math::multiply(p_soa_used_with_aos_in_excluded_fun,
+            stan::math::size(tp_aos_vec_v)),
+          "assigning variable tp_soa_used_with_aos_in_excluded_fun");
+        current_statement__ = 33;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::add(alpha,
+                           stan::math::multiply(dat_x,
+                             stan::math::add(p_soa_vec_v,
+                               tp_soa_used_with_aos_in_excluded_fun))), 1.0));
+        current_statement__ = 34;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::add(alpha,
+                           stan::math::multiply(dat_x, p_soa_vec_v)), 1.0));
+        current_statement__ = 35;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::multiply(dat_x,
+                           stan::model::rvalue(p_soa_mat_uni_col_idx,
+                             "p_soa_mat_uni_col_idx",
+                             stan::model::index_omni(),
+                             stan::model::index_uni(N))), 1.0));
+        current_statement__ = 36;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::multiply(dat_x,
+                           stan::model::rvalue(p_soa_mat_uni_col_idx,
+                             "p_soa_mat_uni_col_idx",
+                             stan::model::index_omni(),
+                             stan::model::index_uni(N))),
+                         stan::model::rvalue(p_soa_vec_uni_idx,
+                           "p_soa_vec_uni_idx", stan::model::index_uni(N))));
+        current_statement__ = 37;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::multiply(dat_x,
+                           udf_fun(tp_aos_fail_func_vec_v, pstream__)),
+                         stan::model::rvalue(p_soa_vec_uni_idx,
+                           "p_soa_vec_uni_idx", stan::model::index_uni(N))));
+        current_statement__ = 38;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::multiply(p_soa_mat,
+                           udf_fun(tp_aos_fail_func_vec_v, pstream__)),
+                         stan::model::rvalue(p_soa_vec_uni_idx,
+                           "p_soa_vec_uni_idx", stan::model::index_uni(N))));
+        current_statement__ = 39;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::multiply(p_soa_mat,
+                           udf_fun(tp_aos_fail_assign_from_top_idx, pstream__)),
+                         stan::model::rvalue(p_soa_vec_uni_idx,
+                           "p_soa_vec_uni_idx", stan::model::index_uni(N))));
+        current_statement__ = 40;
+        lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                         stan::math::multiply(p_soa_mat,
+                           udf_fun(
+                             stan::math::multiply(p_aos_mat,
+                               tp_aos_fail_func_vec_v), pstream__)),
+                         stan::model::rvalue(p_soa_vec_uni_idx,
+                           "p_soa_vec_uni_idx", stan::model::index_uni(N))));
+        current_statement__ = 41;
+        stan::math::validate_non_negative_index("tp_soa_single_assign", "N",
+          N);
+        Eigen::Matrix<local_scalar_t__,-1,1> tp_soa_single_assign =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 43;
+        stan::model::assign(tp_soa_single_assign, 2.0,
+          "assigning variable tp_soa_single_assign",
+          stan::model::index_uni(1));
+        current_statement__ = 44;
+        stan::math::validate_non_negative_index(
+          "tp_soa_single_assign_from_soa", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1> tp_soa_single_assign_from_soa =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 46;
+        stan::model::assign(tp_soa_single_assign_from_soa,
+          stan::math::multiply(p_soa_lhs_loop_mul, p_soa_rhs_loop_mul),
+          "assigning variable tp_soa_single_assign_from_soa",
+          stan::model::index_uni(2));
+        current_statement__ = 57;
+        for (int i = 1; i <= 10; ++i) {
+          current_statement__ = 47;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(dat_x,
+                             stan::model::rvalue(p_soa_arr_vec_v,
+                               "p_soa_arr_vec_v", stan::model::index_uni(i))),
+                           1.0));
+          current_statement__ = 48;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(dat_x,
+                             stan::model::rvalue(p_soa_loop_mat_uni_col_idx,
+                               "p_soa_loop_mat_uni_col_idx",
+                               stan::model::index_omni(),
+                               stan::model::index_uni(i))), 1.0));
+          current_statement__ = 49;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(
+                             stan::model::rvalue(p_soa_loop_mat_uni_col_idx,
+                               "p_soa_loop_mat_uni_col_idx",
+                               stan::model::index_uni(i),
+                               stan::model::index_omni()), dat_x), 1.0));
+          current_statement__ = 50;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(dat_x,
+                             stan::math::transpose(
+                               stan::model::rvalue(
+                                 p_soa_loop_mat_uni_col_idx,
+                                 "p_soa_loop_mat_uni_col_idx",
+                                 stan::model::index_uni(i),
+                                 stan::model::index_omni()))), 1.0));
+          current_statement__ = 51;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(dat_x,
+                             stan::model::rvalue(p_soa_loop_mat_uni_col_idx,
+                               "p_soa_loop_mat_uni_col_idx",
+                               stan::model::index_min_max(1, N),
+                               stan::model::index_uni(1))), 1.0));
+          current_statement__ = 52;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(dat_x,
+                             stan::math::transpose(
+                               stan::model::rvalue(
+                                 p_soa_loop_mat_uni_col_idx,
+                                 "p_soa_loop_mat_uni_col_idx",
+                                 stan::model::index_uni(i)))), 1.0));
+          current_statement__ = 53;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(dat_x,
+                             stan::math::transpose(
+                               stan::model::rvalue(
+                                 p_soa_loop_mat_multi_uni_uni_idx,
+                                 "p_soa_loop_mat_multi_uni_uni_idx",
+                                 stan::model::index_uni(
+                                   stan::model::rvalue(idx_tester,
+                                     "idx_tester", stan::model::index_uni(i))),
+                                 stan::model::index_omni()))), 1.0));
+          current_statement__ = 54;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(
+                             stan::model::rvalue(dat_x, "dat_x",
+                               stan::model::index_omni(),
+                               stan::model::index_uni(i)),
+                             stan::model::rvalue(
+                               stan::math::transpose(
+                                 stan::math::multiply(
+                                   p_aos_mat_pass_func_outer_single_indexed1,
+                                   p_aos_mat_pass_func_outer_single_indexed2)),
+                               "transpose(multiply(p_aos_mat_pass_func_outer_single_indexed1,\n                   p_aos_mat_pass_func_outer_single_indexed2))",
+                               stan::model::index_uni(mask_fun(i, pstream__)),
+                               stan::model::index_uni(mask_fun(i, pstream__)))),
+                           1.0));
+          current_statement__ = 55;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(
+                             stan::model::rvalue(dat_x, "dat_x",
+                               stan::model::index_omni(),
+                               stan::model::index_uni(i)),
+                             (stan::model::rvalue(
+                                p_aos_mat_fail_uni_uni_idx1,
+                                "p_aos_mat_fail_uni_uni_idx1",
+                                stan::model::index_uni(i),
+                                stan::model::index_uni(i)) *
+                             stan::model::rvalue(p_aos_mat_fail_uni_uni_idx2,
+                               "p_aos_mat_fail_uni_uni_idx2",
+                               stan::model::index_uni(i),
+                               stan::model::index_uni(i)))), 1.0));
+        }
+        current_statement__ = 58;
+        stan::math::validate_non_negative_index("tp_aos_loop_vec_v_uni_idx",
+          "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1> tp_aos_loop_vec_v_uni_idx =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 60;
+        stan::math::validate_non_negative_index(
+          "tp_aos_loop_vec_v_multi_uni_idx", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1>
+          tp_aos_loop_vec_v_multi_uni_idx =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 68;
+        for (int i = 1; i <= N; ++i) {
+          current_statement__ = 62;
+          stan::model::assign(tp_aos_loop_vec_v_uni_idx,
+            stan::math::multiply(p_soa_lhs_loop_mul, p_soa_rhs_loop_mul),
+            "assigning variable tp_aos_loop_vec_v_uni_idx",
+            stan::model::index_uni(i));
+          current_statement__ = 63;
+          stan::model::assign(tp_aos_loop_vec_v_multi_uni_idx,
+            stan::math::multiply(p_soa_lhs_loop_mul, p_soa_rhs_loop_mul),
+            "assigning variable tp_aos_loop_vec_v_multi_uni_idx",
+            stan::model::index_uni(
+              stan::model::rvalue(idx_tester, "idx_tester",
+                stan::model::index_uni(i))));
+          current_statement__ = 64;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(
+                             stan::model::rvalue(dat_x, "dat_x",
+                               stan::model::index_omni(),
+                               stan::model::index_uni(i)),
+                             stan::model::rvalue(p_aos_loop_vec_v_uni_idx,
+                               "p_aos_loop_vec_v_uni_idx",
+                               stan::model::index_uni(i))), 1.0));
+          current_statement__ = 65;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::math::multiply(
+                             stan::model::rvalue(dat_x, "dat_x",
+                               stan::model::index_omni(),
+                               stan::model::index_uni(i)),
+                             stan::model::rvalue(p_aos_loop_mat_uni_uni_idx,
+                               "p_aos_loop_mat_uni_uni_idx",
+                               stan::model::index_uni(i),
+                               stan::model::index_uni(i))), 1.0));
+          current_statement__ = 66;
+          lp_accum__.add(stan::math::normal_lpdf<propto__>(y,
+                           stan::model::rvalue(dat_x, "dat_x",
+                             stan::model::index_omni(),
+                             stan::model::index_uni(i)),
+                           (stan::model::rvalue(p_aos_mat_fail_uni_uni_idx1,
+                              "p_aos_mat_fail_uni_uni_idx1",
+                              stan::model::index_uni(i),
+                              stan::model::index_uni(i)) *
+                           stan::model::rvalue(p_aos_mat_fail_uni_uni_idx2,
+                             "p_aos_mat_fail_uni_uni_idx2",
+                             stan::model::index_uni(i),
+                             stan::model::index_uni(i)))));
+        }
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  template <typename RNG, typename VecR, typename VecI, typename VecVar,
+            stan::require_vector_like_vt<std::is_floating_point,
+            VecR>* = nullptr, stan::require_vector_like_vt<std::is_integral,
+            VecI>* = nullptr, stan::require_vector_vt<std::is_floating_point,
+            VecVar>* = nullptr>
+  inline void
+  write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__,
+                   VecVar& vars__, const bool
+                   emit_transformed_parameters__ = true, const bool
+                   emit_generated_quantities__ = true, std::ostream*
+                   pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    static constexpr bool propto__ = true;
+    // suppress unused var warning
+    (void) propto__;
+    double lp__ = 0.0;
+    // suppress unused var warning
+    (void) lp__;
+    int current_statement__ = 0;
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    constexpr bool jacobian__ = false;
+    // suppress unused var warning
+    (void) jacobian__;
+    static constexpr const char* function__ =
+      "indexing_model_namespace::write_array";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      double alpha = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 1;
+      alpha = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<double,-1,1> p_soa_vec_v =
+        Eigen::Matrix<double,-1,1>::Constant(M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 2;
+      p_soa_vec_v = in__.template read<
+                      Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<double,-1,-1> p_soa_mat =
+        Eigen::Matrix<double,-1,-1>::Constant(N, M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 3;
+      p_soa_mat = in__.template read<
+                    Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M);
+      std::vector<Eigen::Matrix<double,-1,1>> p_soa_arr_vec_v =
+        std::vector<Eigen::Matrix<double,-1,1>>(10,
+          Eigen::Matrix<double,-1,1>::Constant(N,
+            std::numeric_limits<double>::quiet_NaN()));
+      current_statement__ = 4;
+      p_soa_arr_vec_v = in__.template read<
+                          std::vector<Eigen::Matrix<local_scalar_t__,-1,1>>>(10,
+                          N);
+      Eigen::Matrix<double,-1,-1> p_soa_mat_uni_col_idx =
+        Eigen::Matrix<double,-1,-1>::Constant(N, M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 5;
+      p_soa_mat_uni_col_idx = in__.template read<
+                                Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M);
+      Eigen::Matrix<double,-1,1> p_soa_vec_uni_idx =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 6;
+      p_soa_vec_uni_idx = in__.template read<
+                            Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      Eigen::Matrix<double,-1,-1> p_soa_loop_mat_uni_col_idx =
+        Eigen::Matrix<double,-1,-1>::Constant(N, M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 7;
+      p_soa_loop_mat_uni_col_idx = in__.template read<
+                                     Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                     M);
+      Eigen::Matrix<double,1,-1> p_soa_lhs_loop_mul =
+        Eigen::Matrix<double,1,-1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 8;
+      p_soa_lhs_loop_mul = in__.template read<
+                             Eigen::Matrix<local_scalar_t__,1,-1>>(N);
+      Eigen::Matrix<double,-1,1> p_soa_rhs_loop_mul =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 9;
+      p_soa_rhs_loop_mul = in__.template read<
+                             Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      Eigen::Matrix<double,-1,1> p_soa_used_with_aos_in_excluded_fun =
+        Eigen::Matrix<double,-1,1>::Constant(N,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 10;
+      p_soa_used_with_aos_in_excluded_fun = in__.template read<
+                                              Eigen::Matrix<local_scalar_t__,-1,1>>(N);
+      Eigen::Matrix<double,-1,-1> p_soa_loop_mat_multi_uni_uni_idx =
+        Eigen::Matrix<double,-1,-1>::Constant(N, M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 11;
+      p_soa_loop_mat_multi_uni_uni_idx = in__.template read<
+                                           Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                           M);
+      Eigen::Matrix<double,-1,1> p_aos_vec_v_assign_to_aos =
+        Eigen::Matrix<double,-1,1>::Constant(M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 12;
+      p_aos_vec_v_assign_to_aos = in__.template read<
+                                    Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<double,-1,1> p_aos_vec_v_tp_fails_func =
+        Eigen::Matrix<double,-1,1>::Constant(M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 13;
+      p_aos_vec_v_tp_fails_func = in__.template read<
+                                    Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<double,-1,1> p_aos_loop_vec_v_uni_idx =
+        Eigen::Matrix<double,-1,1>::Constant(M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 14;
+      p_aos_loop_vec_v_uni_idx = in__.template read<
+                                   Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<double,-1,1> p_aos_fail_assign_from_top_idx =
+        Eigen::Matrix<double,-1,1>::Constant(M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 15;
+      p_aos_fail_assign_from_top_idx = in__.template read<
+                                         Eigen::Matrix<local_scalar_t__,-1,1>>(M);
+      Eigen::Matrix<double,-1,-1> p_aos_loop_mat_uni_uni_idx =
+        Eigen::Matrix<double,-1,-1>::Constant(N, M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 16;
+      p_aos_loop_mat_uni_uni_idx = in__.template read<
+                                     Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                     M);
+      Eigen::Matrix<double,-1,-1> p_aos_mat =
+        Eigen::Matrix<double,-1,-1>::Constant(N, M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 17;
+      p_aos_mat = in__.template read<
+                    Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M);
+      Eigen::Matrix<double,-1,-1> p_aos_mat_pass_func_outer_single_indexed1 =
+        Eigen::Matrix<double,-1,-1>::Constant(N, M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 18;
+      p_aos_mat_pass_func_outer_single_indexed1 = in__.template read<
+                                                    Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                                    M);
+      Eigen::Matrix<double,-1,-1> p_aos_mat_pass_func_outer_single_indexed2 =
+        Eigen::Matrix<double,-1,-1>::Constant(N, M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 19;
+      p_aos_mat_pass_func_outer_single_indexed2 = in__.template read<
+                                                    Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                                    M);
+      Eigen::Matrix<double,-1,-1> p_aos_mat_fail_uni_uni_idx1 =
+        Eigen::Matrix<double,-1,-1>::Constant(N, M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 20;
+      p_aos_mat_fail_uni_uni_idx1 = in__.template read<
+                                      Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                      M);
+      Eigen::Matrix<double,-1,-1> p_aos_mat_fail_uni_uni_idx2 =
+        Eigen::Matrix<double,-1,-1>::Constant(N, M,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 21;
+      p_aos_mat_fail_uni_uni_idx2 = in__.template read<
+                                      Eigen::Matrix<local_scalar_t__,-1,-1>>(N,
+                                      M);
+      double tp_real_from_aos = std::numeric_limits<double>::quiet_NaN();
+      Eigen::Matrix<double,-1,1> tp_aos_vec_v =
+        Eigen::Matrix<double,-1,1>::Constant(M,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,1> tp_soa_single_idx_uninit =
+        Eigen::Matrix<double,-1,1>::Constant(M,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,1> tp_aos_fail_func_vec_v =
+        Eigen::Matrix<double,-1,1>::Constant(M,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,1> tp_aos_fail_assign_from_top_idx =
+        Eigen::Matrix<double,-1,1>::Constant(M,
+          std::numeric_limits<double>::quiet_NaN());
+      out__.write(alpha);
+      out__.write(p_soa_vec_v);
+      out__.write(p_soa_mat);
+      current_statement__ = 4;
+      for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          out__.write(p_soa_arr_vec_v[(sym2__ - 1)][(sym1__ - 1)]);
+        }
+      }
+      out__.write(p_soa_mat_uni_col_idx);
+      out__.write(p_soa_vec_uni_idx);
+      out__.write(p_soa_loop_mat_uni_col_idx);
+      out__.write(p_soa_lhs_loop_mul);
+      out__.write(p_soa_rhs_loop_mul);
+      out__.write(p_soa_used_with_aos_in_excluded_fun);
+      out__.write(p_soa_loop_mat_multi_uni_uni_idx);
+      out__.write(p_aos_vec_v_assign_to_aos);
+      out__.write(p_aos_vec_v_tp_fails_func);
+      out__.write(p_aos_loop_vec_v_uni_idx);
+      out__.write(p_aos_fail_assign_from_top_idx);
+      out__.write(p_aos_loop_mat_uni_uni_idx);
+      out__.write(p_aos_mat);
+      out__.write(p_aos_mat_pass_func_outer_single_indexed1);
+      out__.write(p_aos_mat_pass_func_outer_single_indexed2);
+      out__.write(p_aos_mat_fail_uni_uni_idx1);
+      out__.write(p_aos_mat_fail_uni_uni_idx2);
+      if (stan::math::logical_negation(
+            (stan::math::primitive_value(emit_transformed_parameters__) ||
+            stan::math::primitive_value(emit_generated_quantities__)))) {
+        return ;
+      }
+      current_statement__ = 22;
+      tp_real_from_aos = stan::model::rvalue(p_soa_vec_v, "p_soa_vec_v",
+                           stan::model::index_uni(1));
+      current_statement__ = 23;
+      stan::model::assign(tp_aos_vec_v,
+        udf_fun(p_aos_vec_v_assign_to_aos, pstream__),
+        "assigning variable tp_aos_vec_v");
+      current_statement__ = 27;
+      stan::model::assign(tp_soa_single_idx_uninit, tp_real_from_aos,
+        "assigning variable tp_soa_single_idx_uninit",
+        stan::model::index_uni(1));
+      current_statement__ = 28;
+      stan::model::assign(tp_soa_single_idx_uninit,
+        stan::math::rep_vector(tp_real_from_aos, (M - 1)),
+        "assigning variable tp_soa_single_idx_uninit",
+        stan::model::index_min_max(2, M));
+      current_statement__ = 25;
+      stan::model::assign(tp_aos_fail_func_vec_v, p_aos_vec_v_tp_fails_func,
+        "assigning variable tp_aos_fail_func_vec_v");
+      current_statement__ = 29;
+      stan::model::assign(tp_aos_fail_func_vec_v,
+        stan::model::rvalue(p_soa_vec_v, "p_soa_vec_v",
+          stan::model::index_uni(1)),
+        "assigning variable tp_aos_fail_func_vec_v",
+        stan::model::index_uni(1));
+      current_statement__ = 30;
+      stan::model::assign(tp_aos_fail_assign_from_top_idx,
+        stan::model::rvalue(p_aos_fail_assign_from_top_idx,
+          "p_aos_fail_assign_from_top_idx", stan::model::index_min(1)),
+        "assigning variable tp_aos_fail_assign_from_top_idx",
+        stan::model::index_min(1));
+      if (emit_transformed_parameters__) {
+        out__.write(tp_real_from_aos);
+        out__.write(tp_aos_vec_v);
+        out__.write(tp_soa_single_idx_uninit);
+        out__.write(tp_aos_fail_func_vec_v);
+        out__.write(tp_aos_fail_assign_from_top_idx);
+      }
+      if (stan::math::logical_negation(emit_generated_quantities__)) {
+        return ;
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, typename VecI,
+            stan::require_vector_t<VecVar>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr>
+  inline void
+  unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__,
+                         VecVar& vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      local_scalar_t__ alpha = DUMMY_VAR__;
+      current_statement__ = 1;
+      alpha = in__.read<local_scalar_t__>();
+      out__.write(alpha);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_soa_vec_v =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 2;
+      stan::model::assign(p_soa_vec_v,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(M),
+        "assigning variable p_soa_vec_v");
+      out__.write(p_soa_vec_v);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_soa_mat =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 3;
+      stan::model::assign(p_soa_mat,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M),
+        "assigning variable p_soa_mat");
+      out__.write(p_soa_mat);
+      std::vector<Eigen::Matrix<local_scalar_t__,-1,1>> p_soa_arr_vec_v =
+        std::vector<Eigen::Matrix<local_scalar_t__,-1,1>>(10,
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__));
+      current_statement__ = 4;
+      for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          current_statement__ = 4;
+          stan::model::assign(p_soa_arr_vec_v, in__.read<local_scalar_t__>(),
+            "assigning variable p_soa_arr_vec_v",
+            stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+        }
+      }
+      out__.write(p_soa_arr_vec_v);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_soa_mat_uni_col_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 5;
+      stan::model::assign(p_soa_mat_uni_col_idx,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M),
+        "assigning variable p_soa_mat_uni_col_idx");
+      out__.write(p_soa_mat_uni_col_idx);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_soa_vec_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 6;
+      stan::model::assign(p_soa_vec_uni_idx,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(N),
+        "assigning variable p_soa_vec_uni_idx");
+      out__.write(p_soa_vec_uni_idx);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_soa_loop_mat_uni_col_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 7;
+      stan::model::assign(p_soa_loop_mat_uni_col_idx,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M),
+        "assigning variable p_soa_loop_mat_uni_col_idx");
+      out__.write(p_soa_loop_mat_uni_col_idx);
+      Eigen::Matrix<local_scalar_t__,1,-1> p_soa_lhs_loop_mul =
+        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 8;
+      stan::model::assign(p_soa_lhs_loop_mul,
+        in__.read<Eigen::Matrix<local_scalar_t__,1,-1>>(N),
+        "assigning variable p_soa_lhs_loop_mul");
+      out__.write(p_soa_lhs_loop_mul);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_soa_rhs_loop_mul =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 9;
+      stan::model::assign(p_soa_rhs_loop_mul,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(N),
+        "assigning variable p_soa_rhs_loop_mul");
+      out__.write(p_soa_rhs_loop_mul);
+      Eigen::Matrix<local_scalar_t__,-1,1>
+        p_soa_used_with_aos_in_excluded_fun =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      current_statement__ = 10;
+      stan::model::assign(p_soa_used_with_aos_in_excluded_fun,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(N),
+        "assigning variable p_soa_used_with_aos_in_excluded_fun");
+      out__.write(p_soa_used_with_aos_in_excluded_fun);
+      Eigen::Matrix<local_scalar_t__,-1,-1>
+        p_soa_loop_mat_multi_uni_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 11;
+      stan::model::assign(p_soa_loop_mat_multi_uni_uni_idx,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M),
+        "assigning variable p_soa_loop_mat_multi_uni_uni_idx");
+      out__.write(p_soa_loop_mat_multi_uni_uni_idx);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_vec_v_assign_to_aos =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 12;
+      stan::model::assign(p_aos_vec_v_assign_to_aos,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(M),
+        "assigning variable p_aos_vec_v_assign_to_aos");
+      out__.write(p_aos_vec_v_assign_to_aos);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_vec_v_tp_fails_func =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 13;
+      stan::model::assign(p_aos_vec_v_tp_fails_func,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(M),
+        "assigning variable p_aos_vec_v_tp_fails_func");
+      out__.write(p_aos_vec_v_tp_fails_func);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_loop_vec_v_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 14;
+      stan::model::assign(p_aos_loop_vec_v_uni_idx,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(M),
+        "assigning variable p_aos_loop_vec_v_uni_idx");
+      out__.write(p_aos_loop_vec_v_uni_idx);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_fail_assign_from_top_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      current_statement__ = 15;
+      stan::model::assign(p_aos_fail_assign_from_top_idx,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(M),
+        "assigning variable p_aos_fail_assign_from_top_idx");
+      out__.write(p_aos_fail_assign_from_top_idx);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_loop_mat_uni_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 16;
+      stan::model::assign(p_aos_loop_mat_uni_uni_idx,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M),
+        "assigning variable p_aos_loop_mat_uni_uni_idx");
+      out__.write(p_aos_loop_mat_uni_uni_idx);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_mat =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 17;
+      stan::model::assign(p_aos_mat,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M),
+        "assigning variable p_aos_mat");
+      out__.write(p_aos_mat);
+      Eigen::Matrix<local_scalar_t__,-1,-1>
+        p_aos_mat_pass_func_outer_single_indexed1 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 18;
+      stan::model::assign(p_aos_mat_pass_func_outer_single_indexed1,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M),
+        "assigning variable p_aos_mat_pass_func_outer_single_indexed1");
+      out__.write(p_aos_mat_pass_func_outer_single_indexed1);
+      Eigen::Matrix<local_scalar_t__,-1,-1>
+        p_aos_mat_pass_func_outer_single_indexed2 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 19;
+      stan::model::assign(p_aos_mat_pass_func_outer_single_indexed2,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M),
+        "assigning variable p_aos_mat_pass_func_outer_single_indexed2");
+      out__.write(p_aos_mat_pass_func_outer_single_indexed2);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_mat_fail_uni_uni_idx1 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 20;
+      stan::model::assign(p_aos_mat_fail_uni_uni_idx1,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M),
+        "assigning variable p_aos_mat_fail_uni_uni_idx1");
+      out__.write(p_aos_mat_fail_uni_uni_idx1);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_mat_fail_uni_uni_idx2 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      current_statement__ = 21;
+      stan::model::assign(p_aos_mat_fail_uni_uni_idx2,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(N, M),
+        "assigning variable p_aos_mat_fail_uni_uni_idx2");
+      out__.write(p_aos_mat_fail_uni_uni_idx2);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, stan::require_vector_t<VecVar>* = nullptr>
+  inline void
+  transform_inits_impl(const stan::io::var_context& context__, VecVar&
+                       vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 1;
+      context__.validate_dims("parameter initialization", "alpha", "double",
+        std::vector<size_t>{});
+      current_statement__ = 2;
+      context__.validate_dims("parameter initialization", "p_soa_vec_v",
+        "double", std::vector<size_t>{static_cast<size_t>(M)});
+      current_statement__ = 3;
+      context__.validate_dims("parameter initialization", "p_soa_mat",
+        "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(M)});
+      current_statement__ = 4;
+      context__.validate_dims("parameter initialization", "p_soa_arr_vec_v",
+        "double",
+        std::vector<size_t>{static_cast<size_t>(10), static_cast<size_t>(N)});
+      current_statement__ = 5;
+      context__.validate_dims("parameter initialization",
+        "p_soa_mat_uni_col_idx", "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(M)});
+      current_statement__ = 6;
+      context__.validate_dims("parameter initialization",
+        "p_soa_vec_uni_idx", "double",
+        std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 7;
+      context__.validate_dims("parameter initialization",
+        "p_soa_loop_mat_uni_col_idx", "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(M)});
+      current_statement__ = 8;
+      context__.validate_dims("parameter initialization",
+        "p_soa_lhs_loop_mul", "double",
+        std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 9;
+      context__.validate_dims("parameter initialization",
+        "p_soa_rhs_loop_mul", "double",
+        std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 10;
+      context__.validate_dims("parameter initialization",
+        "p_soa_used_with_aos_in_excluded_fun", "double",
+        std::vector<size_t>{static_cast<size_t>(N)});
+      current_statement__ = 11;
+      context__.validate_dims("parameter initialization",
+        "p_soa_loop_mat_multi_uni_uni_idx", "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(M)});
+      current_statement__ = 12;
+      context__.validate_dims("parameter initialization",
+        "p_aos_vec_v_assign_to_aos", "double",
+        std::vector<size_t>{static_cast<size_t>(M)});
+      current_statement__ = 13;
+      context__.validate_dims("parameter initialization",
+        "p_aos_vec_v_tp_fails_func", "double",
+        std::vector<size_t>{static_cast<size_t>(M)});
+      current_statement__ = 14;
+      context__.validate_dims("parameter initialization",
+        "p_aos_loop_vec_v_uni_idx", "double",
+        std::vector<size_t>{static_cast<size_t>(M)});
+      current_statement__ = 15;
+      context__.validate_dims("parameter initialization",
+        "p_aos_fail_assign_from_top_idx", "double",
+        std::vector<size_t>{static_cast<size_t>(M)});
+      current_statement__ = 16;
+      context__.validate_dims("parameter initialization",
+        "p_aos_loop_mat_uni_uni_idx", "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(M)});
+      current_statement__ = 17;
+      context__.validate_dims("parameter initialization", "p_aos_mat",
+        "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(M)});
+      current_statement__ = 18;
+      context__.validate_dims("parameter initialization",
+        "p_aos_mat_pass_func_outer_single_indexed1", "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(M)});
+      current_statement__ = 19;
+      context__.validate_dims("parameter initialization",
+        "p_aos_mat_pass_func_outer_single_indexed2", "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(M)});
+      current_statement__ = 20;
+      context__.validate_dims("parameter initialization",
+        "p_aos_mat_fail_uni_uni_idx1", "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(M)});
+      current_statement__ = 21;
+      context__.validate_dims("parameter initialization",
+        "p_aos_mat_fail_uni_uni_idx2", "double",
+        std::vector<size_t>{static_cast<size_t>(N), static_cast<size_t>(M)});
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      local_scalar_t__ alpha = DUMMY_VAR__;
+      current_statement__ = 1;
+      alpha = context__.vals_r("alpha")[(1 - 1)];
+      out__.write(alpha);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_soa_vec_v =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_soa_vec_v_flat__;
+        current_statement__ = 2;
+        p_soa_vec_v_flat__ = context__.vals_r("p_soa_vec_v");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          stan::model::assign(p_soa_vec_v, p_soa_vec_v_flat__[(pos__ - 1)],
+            "assigning variable p_soa_vec_v", stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(p_soa_vec_v);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_soa_mat =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_soa_mat_flat__;
+        current_statement__ = 3;
+        p_soa_mat_flat__ = context__.vals_r("p_soa_mat");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(p_soa_mat, p_soa_mat_flat__[(pos__ - 1)],
+              "assigning variable p_soa_mat", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(p_soa_mat);
+      std::vector<Eigen::Matrix<local_scalar_t__,-1,1>> p_soa_arr_vec_v =
+        std::vector<Eigen::Matrix<local_scalar_t__,-1,1>>(10,
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__));
+      {
+        std::vector<local_scalar_t__> p_soa_arr_vec_v_flat__;
+        current_statement__ = 4;
+        p_soa_arr_vec_v_flat__ = context__.vals_r("p_soa_arr_vec_v");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+            stan::model::assign(p_soa_arr_vec_v,
+              p_soa_arr_vec_v_flat__[(pos__ - 1)],
+              "assigning variable p_soa_arr_vec_v",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(p_soa_arr_vec_v);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_soa_mat_uni_col_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_soa_mat_uni_col_idx_flat__;
+        current_statement__ = 5;
+        p_soa_mat_uni_col_idx_flat__ = context__.vals_r("p_soa_mat_uni_col_idx");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(p_soa_mat_uni_col_idx,
+              p_soa_mat_uni_col_idx_flat__[(pos__ - 1)],
+              "assigning variable p_soa_mat_uni_col_idx",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(p_soa_mat_uni_col_idx);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_soa_vec_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_soa_vec_uni_idx_flat__;
+        current_statement__ = 6;
+        p_soa_vec_uni_idx_flat__ = context__.vals_r("p_soa_vec_uni_idx");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(p_soa_vec_uni_idx,
+            p_soa_vec_uni_idx_flat__[(pos__ - 1)],
+            "assigning variable p_soa_vec_uni_idx",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(p_soa_vec_uni_idx);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_soa_loop_mat_uni_col_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_soa_loop_mat_uni_col_idx_flat__;
+        current_statement__ = 7;
+        p_soa_loop_mat_uni_col_idx_flat__ = context__.vals_r("p_soa_loop_mat_uni_col_idx");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(p_soa_loop_mat_uni_col_idx,
+              p_soa_loop_mat_uni_col_idx_flat__[(pos__ - 1)],
+              "assigning variable p_soa_loop_mat_uni_col_idx",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(p_soa_loop_mat_uni_col_idx);
+      Eigen::Matrix<local_scalar_t__,1,-1> p_soa_lhs_loop_mul =
+        Eigen::Matrix<local_scalar_t__,1,-1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_soa_lhs_loop_mul_flat__;
+        current_statement__ = 8;
+        p_soa_lhs_loop_mul_flat__ = context__.vals_r("p_soa_lhs_loop_mul");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(p_soa_lhs_loop_mul,
+            p_soa_lhs_loop_mul_flat__[(pos__ - 1)],
+            "assigning variable p_soa_lhs_loop_mul",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(p_soa_lhs_loop_mul);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_soa_rhs_loop_mul =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_soa_rhs_loop_mul_flat__;
+        current_statement__ = 9;
+        p_soa_rhs_loop_mul_flat__ = context__.vals_r("p_soa_rhs_loop_mul");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(p_soa_rhs_loop_mul,
+            p_soa_rhs_loop_mul_flat__[(pos__ - 1)],
+            "assigning variable p_soa_rhs_loop_mul",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(p_soa_rhs_loop_mul);
+      Eigen::Matrix<local_scalar_t__,-1,1>
+        p_soa_used_with_aos_in_excluded_fun =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__>
+          p_soa_used_with_aos_in_excluded_fun_flat__;
+        current_statement__ = 10;
+        p_soa_used_with_aos_in_excluded_fun_flat__ = context__.vals_r("p_soa_used_with_aos_in_excluded_fun");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+          stan::model::assign(p_soa_used_with_aos_in_excluded_fun,
+            p_soa_used_with_aos_in_excluded_fun_flat__[(pos__ - 1)],
+            "assigning variable p_soa_used_with_aos_in_excluded_fun",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(p_soa_used_with_aos_in_excluded_fun);
+      Eigen::Matrix<local_scalar_t__,-1,-1>
+        p_soa_loop_mat_multi_uni_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_soa_loop_mat_multi_uni_uni_idx_flat__;
+        current_statement__ = 11;
+        p_soa_loop_mat_multi_uni_uni_idx_flat__ = context__.vals_r("p_soa_loop_mat_multi_uni_uni_idx");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(p_soa_loop_mat_multi_uni_uni_idx,
+              p_soa_loop_mat_multi_uni_uni_idx_flat__[(pos__ - 1)],
+              "assigning variable p_soa_loop_mat_multi_uni_uni_idx",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(p_soa_loop_mat_multi_uni_uni_idx);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_vec_v_assign_to_aos =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_aos_vec_v_assign_to_aos_flat__;
+        current_statement__ = 12;
+        p_aos_vec_v_assign_to_aos_flat__ = context__.vals_r("p_aos_vec_v_assign_to_aos");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          stan::model::assign(p_aos_vec_v_assign_to_aos,
+            p_aos_vec_v_assign_to_aos_flat__[(pos__ - 1)],
+            "assigning variable p_aos_vec_v_assign_to_aos",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(p_aos_vec_v_assign_to_aos);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_vec_v_tp_fails_func =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_aos_vec_v_tp_fails_func_flat__;
+        current_statement__ = 13;
+        p_aos_vec_v_tp_fails_func_flat__ = context__.vals_r("p_aos_vec_v_tp_fails_func");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          stan::model::assign(p_aos_vec_v_tp_fails_func,
+            p_aos_vec_v_tp_fails_func_flat__[(pos__ - 1)],
+            "assigning variable p_aos_vec_v_tp_fails_func",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(p_aos_vec_v_tp_fails_func);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_loop_vec_v_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_aos_loop_vec_v_uni_idx_flat__;
+        current_statement__ = 14;
+        p_aos_loop_vec_v_uni_idx_flat__ = context__.vals_r("p_aos_loop_vec_v_uni_idx");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          stan::model::assign(p_aos_loop_vec_v_uni_idx,
+            p_aos_loop_vec_v_uni_idx_flat__[(pos__ - 1)],
+            "assigning variable p_aos_loop_vec_v_uni_idx",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(p_aos_loop_vec_v_uni_idx);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_fail_assign_from_top_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_aos_fail_assign_from_top_idx_flat__;
+        current_statement__ = 15;
+        p_aos_fail_assign_from_top_idx_flat__ = context__.vals_r("p_aos_fail_assign_from_top_idx");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          stan::model::assign(p_aos_fail_assign_from_top_idx,
+            p_aos_fail_assign_from_top_idx_flat__[(pos__ - 1)],
+            "assigning variable p_aos_fail_assign_from_top_idx",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(p_aos_fail_assign_from_top_idx);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_loop_mat_uni_uni_idx =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_aos_loop_mat_uni_uni_idx_flat__;
+        current_statement__ = 16;
+        p_aos_loop_mat_uni_uni_idx_flat__ = context__.vals_r("p_aos_loop_mat_uni_uni_idx");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(p_aos_loop_mat_uni_uni_idx,
+              p_aos_loop_mat_uni_uni_idx_flat__[(pos__ - 1)],
+              "assigning variable p_aos_loop_mat_uni_uni_idx",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(p_aos_loop_mat_uni_uni_idx);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_mat =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_aos_mat_flat__;
+        current_statement__ = 17;
+        p_aos_mat_flat__ = context__.vals_r("p_aos_mat");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(p_aos_mat, p_aos_mat_flat__[(pos__ - 1)],
+              "assigning variable p_aos_mat", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(p_aos_mat);
+      Eigen::Matrix<local_scalar_t__,-1,-1>
+        p_aos_mat_pass_func_outer_single_indexed1 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__>
+          p_aos_mat_pass_func_outer_single_indexed1_flat__;
+        current_statement__ = 18;
+        p_aos_mat_pass_func_outer_single_indexed1_flat__ = context__.vals_r("p_aos_mat_pass_func_outer_single_indexed1");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(p_aos_mat_pass_func_outer_single_indexed1,
+              p_aos_mat_pass_func_outer_single_indexed1_flat__[(pos__ - 1)],
+              "assigning variable p_aos_mat_pass_func_outer_single_indexed1",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(p_aos_mat_pass_func_outer_single_indexed1);
+      Eigen::Matrix<local_scalar_t__,-1,-1>
+        p_aos_mat_pass_func_outer_single_indexed2 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__>
+          p_aos_mat_pass_func_outer_single_indexed2_flat__;
+        current_statement__ = 19;
+        p_aos_mat_pass_func_outer_single_indexed2_flat__ = context__.vals_r("p_aos_mat_pass_func_outer_single_indexed2");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(p_aos_mat_pass_func_outer_single_indexed2,
+              p_aos_mat_pass_func_outer_single_indexed2_flat__[(pos__ - 1)],
+              "assigning variable p_aos_mat_pass_func_outer_single_indexed2",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(p_aos_mat_pass_func_outer_single_indexed2);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_mat_fail_uni_uni_idx1 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_aos_mat_fail_uni_uni_idx1_flat__;
+        current_statement__ = 20;
+        p_aos_mat_fail_uni_uni_idx1_flat__ = context__.vals_r("p_aos_mat_fail_uni_uni_idx1");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(p_aos_mat_fail_uni_uni_idx1,
+              p_aos_mat_fail_uni_uni_idx1_flat__[(pos__ - 1)],
+              "assigning variable p_aos_mat_fail_uni_uni_idx1",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(p_aos_mat_fail_uni_uni_idx1);
+      Eigen::Matrix<local_scalar_t__,-1,-1> p_aos_mat_fail_uni_uni_idx2 =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(N, M, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_aos_mat_fail_uni_uni_idx2_flat__;
+        current_statement__ = 21;
+        p_aos_mat_fail_uni_uni_idx2_flat__ = context__.vals_r("p_aos_mat_fail_uni_uni_idx2");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+            stan::model::assign(p_aos_mat_fail_uni_uni_idx2,
+              p_aos_mat_fail_uni_uni_idx2_flat__[(pos__ - 1)],
+              "assigning variable p_aos_mat_fail_uni_uni_idx2",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(p_aos_mat_fail_uni_uni_idx2);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  inline void
+  get_param_names(std::vector<std::string>& names__, const bool
+                  emit_transformed_parameters__ = true, const bool
+                  emit_generated_quantities__ = true) const {
+    names__ = std::vector<std::string>{"alpha", "p_soa_vec_v", "p_soa_mat",
+                "p_soa_arr_vec_v", "p_soa_mat_uni_col_idx",
+                "p_soa_vec_uni_idx", "p_soa_loop_mat_uni_col_idx",
+                "p_soa_lhs_loop_mul", "p_soa_rhs_loop_mul",
+                "p_soa_used_with_aos_in_excluded_fun",
+                "p_soa_loop_mat_multi_uni_uni_idx",
+                "p_aos_vec_v_assign_to_aos", "p_aos_vec_v_tp_fails_func",
+                "p_aos_loop_vec_v_uni_idx", "p_aos_fail_assign_from_top_idx",
+                "p_aos_loop_mat_uni_uni_idx", "p_aos_mat",
+                "p_aos_mat_pass_func_outer_single_indexed1",
+                "p_aos_mat_pass_func_outer_single_indexed2",
+                "p_aos_mat_fail_uni_uni_idx1", "p_aos_mat_fail_uni_uni_idx2"};
+    if (emit_transformed_parameters__) {
+      std::vector<std::string>
+        temp{"tp_real_from_aos", "tp_aos_vec_v", "tp_soa_single_idx_uninit",
+             "tp_aos_fail_func_vec_v", "tp_aos_fail_assign_from_top_idx"};
+      names__.reserve(names__.size() + temp.size());
+      names__.insert(names__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  get_dims(std::vector<std::vector<size_t>>& dimss__, const bool
+           emit_transformed_parameters__ = true, const bool
+           emit_generated_quantities__ = true) const {
+    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{},
+                std::vector<size_t>{static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(N),
+                  static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(10),
+                  static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N),
+                  static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N),
+                  static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N)},
+                std::vector<size_t>{static_cast<size_t>(N),
+                  static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(N),
+                  static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(N),
+                  static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(N),
+                  static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(N),
+                  static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(N),
+                  static_cast<size_t>(M)},
+                std::vector<size_t>{static_cast<size_t>(N),
+                  static_cast<size_t>(M)}};
+    if (emit_transformed_parameters__) {
+      std::vector<std::vector<size_t>>
+        temp{std::vector<size_t>{},
+             std::vector<size_t>{static_cast<size_t>(M)},
+             std::vector<size_t>{static_cast<size_t>(M)},
+             std::vector<size_t>{static_cast<size_t>(M)},
+             std::vector<size_t>{static_cast<size_t>(M)}};
+      dimss__.reserve(dimss__.size() + temp.size());
+      dimss__.insert(dimss__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  constrained_param_names(std::vector<std::string>& param_names__, bool
+                          emit_transformed_parameters__ = true, bool
+                          emit_generated_quantities__ = true) const final {
+    param_names__.emplace_back(std::string() + "alpha");
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_soa_vec_v" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() + "p_soa_mat" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "p_soa_arr_vec_v" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() + "p_soa_mat_uni_col_idx" +
+          '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_soa_vec_uni_idx" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_soa_loop_mat_uni_col_idx" + '.' + std::to_string(sym2__) + '.' +
+          std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_soa_lhs_loop_mul" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_soa_rhs_loop_mul" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() +
+        "p_soa_used_with_aos_in_excluded_fun" + '.' + std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_soa_loop_mat_multi_uni_uni_idx" + '.' + std::to_string(sym2__) +
+          '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_aos_vec_v_assign_to_aos"
+        + '.' + std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_aos_vec_v_tp_fails_func"
+        + '.' + std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_aos_loop_vec_v_uni_idx" +
+        '.' + std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      param_names__.emplace_back(std::string() +
+        "p_aos_fail_assign_from_top_idx" + '.' + std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_aos_loop_mat_uni_uni_idx" + '.' + std::to_string(sym2__) + '.' +
+          std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() + "p_aos_mat" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_aos_mat_pass_func_outer_single_indexed1" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_aos_mat_pass_func_outer_single_indexed2" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_aos_mat_fail_uni_uni_idx1" + '.' + std::to_string(sym2__) + '.'
+          + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_aos_mat_fail_uni_uni_idx2" + '.' + std::to_string(sym2__) + '.'
+          + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      param_names__.emplace_back(std::string() + "tp_real_from_aos");
+      for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+        param_names__.emplace_back(std::string() + "tp_aos_vec_v" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+        param_names__.emplace_back(std::string() + "tp_soa_single_idx_uninit"
+          + '.' + std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+        param_names__.emplace_back(std::string() + "tp_aos_fail_func_vec_v" +
+          '.' + std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+        param_names__.emplace_back(std::string() +
+          "tp_aos_fail_assign_from_top_idx" + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  unconstrained_param_names(std::vector<std::string>& param_names__, bool
+                            emit_transformed_parameters__ = true, bool
+                            emit_generated_quantities__ = true) const final {
+    param_names__.emplace_back(std::string() + "alpha");
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_soa_vec_v" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() + "p_soa_mat" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "p_soa_arr_vec_v" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() + "p_soa_mat_uni_col_idx" +
+          '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_soa_vec_uni_idx" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_soa_loop_mat_uni_col_idx" + '.' + std::to_string(sym2__) + '.' +
+          std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_soa_lhs_loop_mul" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_soa_rhs_loop_mul" + '.' +
+        std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= N; ++sym1__) {
+      param_names__.emplace_back(std::string() +
+        "p_soa_used_with_aos_in_excluded_fun" + '.' + std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_soa_loop_mat_multi_uni_uni_idx" + '.' + std::to_string(sym2__) +
+          '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_aos_vec_v_assign_to_aos"
+        + '.' + std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_aos_vec_v_tp_fails_func"
+        + '.' + std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_aos_loop_vec_v_uni_idx" +
+        '.' + std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      param_names__.emplace_back(std::string() +
+        "p_aos_fail_assign_from_top_idx" + '.' + std::to_string(sym1__));
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_aos_loop_mat_uni_uni_idx" + '.' + std::to_string(sym2__) + '.' +
+          std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() + "p_aos_mat" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_aos_mat_pass_func_outer_single_indexed1" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_aos_mat_pass_func_outer_single_indexed2" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_aos_mat_fail_uni_uni_idx1" + '.' + std::to_string(sym2__) + '.'
+          + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= N; ++sym2__) {
+        param_names__.emplace_back(std::string() +
+          "p_aos_mat_fail_uni_uni_idx2" + '.' + std::to_string(sym2__) + '.'
+          + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      param_names__.emplace_back(std::string() + "tp_real_from_aos");
+      for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+        param_names__.emplace_back(std::string() + "tp_aos_vec_v" + '.' +
+          std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+        param_names__.emplace_back(std::string() + "tp_soa_single_idx_uninit"
+          + '.' + std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+        param_names__.emplace_back(std::string() + "tp_aos_fail_func_vec_v" +
+          '.' + std::to_string(sym1__));
+      }
+      for (int sym1__ = 1; sym1__ <= M; ++sym1__) {
+        param_names__.emplace_back(std::string() +
+          "tp_aos_fail_assign_from_top_idx" + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline std::string get_constrained_sizedtypes() const {
+    return std::string("[{\"name\":\"alpha\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"p_soa_vec_v\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_mat\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_arr_vec_v\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(10) + ",\"element_type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "}},\"block\":\"parameters\"},{\"name\":\"p_soa_mat_uni_col_idx\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_vec_uni_idx\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_loop_mat_uni_col_idx\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_lhs_loop_mul\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_rhs_loop_mul\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_used_with_aos_in_excluded_fun\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_loop_mat_multi_uni_uni_idx\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_vec_v_assign_to_aos\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_vec_v_tp_fails_func\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_loop_vec_v_uni_idx\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_fail_assign_from_top_idx\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_loop_mat_uni_uni_idx\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_mat\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_mat_pass_func_outer_single_indexed1\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_mat_pass_func_outer_single_indexed2\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_mat_fail_uni_uni_idx1\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_mat_fail_uni_uni_idx2\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"tp_real_from_aos\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"tp_aos_vec_v\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"transformed_parameters\"},{\"name\":\"tp_soa_single_idx_uninit\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"transformed_parameters\"},{\"name\":\"tp_aos_fail_func_vec_v\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"transformed_parameters\"},{\"name\":\"tp_aos_fail_assign_from_top_idx\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  inline std::string get_unconstrained_sizedtypes() const {
+    return std::string("[{\"name\":\"alpha\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"p_soa_vec_v\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_mat\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_arr_vec_v\",\"type\":{\"name\":\"array\",\"length\":" + std::to_string(10) + ",\"element_type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "}},\"block\":\"parameters\"},{\"name\":\"p_soa_mat_uni_col_idx\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_vec_uni_idx\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_loop_mat_uni_col_idx\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_lhs_loop_mul\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_rhs_loop_mul\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_used_with_aos_in_excluded_fun\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(N) + "},\"block\":\"parameters\"},{\"name\":\"p_soa_loop_mat_multi_uni_uni_idx\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_vec_v_assign_to_aos\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_vec_v_tp_fails_func\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_loop_vec_v_uni_idx\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_fail_assign_from_top_idx\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_loop_mat_uni_uni_idx\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_mat\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_mat_pass_func_outer_single_indexed1\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_mat_pass_func_outer_single_indexed2\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_mat_fail_uni_uni_idx1\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"p_aos_mat_fail_uni_uni_idx2\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(N) + ",\"cols\":" + std::to_string(M) + "},\"block\":\"parameters\"},{\"name\":\"tp_real_from_aos\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"tp_aos_vec_v\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"transformed_parameters\"},{\"name\":\"tp_soa_single_idx_uninit\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"transformed_parameters\"},{\"name\":\"tp_aos_fail_func_vec_v\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"transformed_parameters\"},{\"name\":\"tp_aos_fail_assign_from_top_idx\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(M) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  // Begin method overload boilerplate
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, Eigen::Matrix<double,-1,1>& params_r,
+              Eigen::Matrix<double,-1,1>& vars, const bool
+              emit_transformed_parameters = true, const bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = ((((((((((((((((((((1 + M) + (N * M)) + (10 *
+      N)) + (N * M)) + N) + (N * M)) + N) + N) + N) + (N * M)) + M) + M) + M)
+      + M) + (N * M)) + (N * M)) + (N * M)) + (N * M)) + (N * M)) + (N * M));
+    const size_t num_transformed = emit_transformed_parameters * (((((1 + M)
+      + M) + M) + M));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    std::vector<int> params_i;
+    vars = Eigen::Matrix<double,-1,1>::Constant(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, std::vector<double>& params_r, std::vector<int>&
+              params_i, std::vector<double>& vars, bool
+              emit_transformed_parameters = true, bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = ((((((((((((((((((((1 + M) + (N * M)) + (10 *
+      N)) + (N * M)) + N) + (N * M)) + N) + N) + N) + (N * M)) + M) + M) + M)
+      + M) + (N * M)) + (N * M)) + (N * M)) + (N * M)) + (N * M)) + (N * M));
+    const size_t num_transformed = emit_transformed_parameters * (((((1 + M)
+      + M) + M) + M));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    vars = std::vector<double>(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(Eigen::Matrix<T_,-1,1>& params_r, std::ostream* pstream = nullptr) const {
+    Eigen::Matrix<int,-1,1> params_i;
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(std::vector<T_>& params_r, std::vector<int>& params_i,
+           std::ostream* pstream = nullptr) const {
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context,
+                  Eigen::Matrix<double,-1,1>& params_r, std::ostream*
+                  pstream = nullptr) const final {
+    std::vector<double> params_r_vec(params_r.size());
+    std::vector<int> params_i;
+    transform_inits(context, params_i, params_r_vec, pstream);
+    params_r = Eigen::Map<Eigen::Matrix<double,-1,1>>(params_r_vec.data(),
+                 params_r_vec.size());
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context, std::vector<int>&
+                  params_i, std::vector<double>& vars, std::ostream*
+                  pstream__ = nullptr) const {
+    vars.resize(num_params_r__);
+    transform_inits_impl(context, vars, pstream__);
+  }
+  inline void
+  unconstrain_array(const std::vector<double>& params_constrained,
+                    std::vector<double>& params_unconstrained, std::ostream*
+                    pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = std::vector<double>(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+  inline void
+  unconstrain_array(const Eigen::Matrix<double,-1,1>& params_constrained,
+                    Eigen::Matrix<double,-1,1>& params_unconstrained,
+                    std::ostream* pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = Eigen::Matrix<double,-1,1>::Constant(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+};
+}
+using stan_model = indexing_model_namespace::indexing_model;
+#ifndef USING_R
+// Boilerplate
+stan::model::model_base&
+new_model(stan::io::var_context& data_context, unsigned int seed,
+          std::ostream* msg_stream) {
+  stan_model* m = new stan_model(data_context, seed, msg_stream);
+  return *m;
+}
+stan::math::profile_map& get_stan_profile_data() {
+  return indexing_model_namespace::profiles__;
+}
+#endif
+OpenCL (Line 59) warning: Right hand side of assignment is all AoS: p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+OpenCL (Line 59) warning: Function on right hand side of assignment is not supported by SoA: p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+OpenCL (Line 63) warning: Function on right hand side of assignment is not supported by SoA: tp_soa_single_idx_uninit
+OpenCL (Line 75) warning: Function size is not supported: tp_aos_vec_v
+OpenCL (Line 80) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v, tp_soa_single_idx_uninit
+OpenCL (Line 81) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v, tp_soa_single_idx_uninit
+OpenCL (Line 82) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v, tp_soa_single_idx_uninit
+OpenCL (Line 83) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v, tp_soa_single_idx_uninit
+OpenCL (Line 101) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v, tp_soa_single_idx_uninit
+OpenCL (Line 101) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v, tp_soa_single_idx_uninit
+OpenCL (Line 111) warning: Accessed by element in a for loop: tp_aos_loop_vec_v_uni_idx
+OpenCL (Line 112) warning: Accessed by element in a for loop: tp_aos_loop_vec_v_multi_uni_idx
+  $ ../../../../../../install/default/bin/stanc --use-opencl --print-cpp indexing2.stan
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace indexing2_model_namespace {
+using stan::model::model_base_crtp;
+using namespace stan::math;
+stan::math::profile_map profiles__;
+static constexpr std::array<const char*, 17> locations_array__ =
+  {" (found before start of program)",
+  " (in 'indexing2.stan', line 8, column 2 to column 13)",
+  " (in 'indexing2.stan', line 9, column 2 to column 35)",
+  " (in 'indexing2.stan', line 13, column 9 to column 10)",
+  " (in 'indexing2.stan', line 13, column 2 to column 67)",
+  " (in 'indexing2.stan', line 16, column 4 to column 97)",
+  " (in 'indexing2.stan', line 15, column 18 to line 17, column 3)",
+  " (in 'indexing2.stan', line 15, column 2 to line 17, column 3)",
+  " (in 'indexing2.stan', line 18, column 9 to column 10)",
+  " (in 'indexing2.stan', line 18, column 2 to column 44)",
+  " (in 'indexing2.stan', line 20, column 2 to column 77)",
+  " (in 'indexing2.stan', line 19, column 17 to line 21, column 3)",
+  " (in 'indexing2.stan', line 19, column 2 to line 21, column 3)",
+  " (in 'indexing2.stan', line 2, column 1 to column 7)",
+  " (in 'indexing2.stan', line 3, column 1 to column 7)",
+  " (in 'indexing2.stan', line 4, column 7 to column 8)",
+  " (in 'indexing2.stan', line 4, column 1 to column 18)"};
+class indexing2_model final : public model_base_crtp<indexing2_model> {
+ private:
+  int N;
+  int M;
+  std::vector<int> Idx;
+ public:
+  ~indexing2_model() {}
+  indexing2_model(stan::io::var_context& context__, unsigned int
+                  random_seed__ = 0, std::ostream* pstream__ = nullptr)
+      : model_base_crtp(0) {
+    int current_statement__ = 0;
+    using local_scalar_t__ = double;
+    boost::ecuyer1988 base_rng__ =
+      stan::services::util::create_rng(random_seed__, 0);
+    // suppress unused var warning
+    (void) base_rng__;
+    static constexpr const char* function__ =
+      "indexing2_model_namespace::indexing2_model";
+    // suppress unused var warning
+    (void) function__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 13;
+      context__.validate_dims("data initialization", "N", "int",
+        std::vector<size_t>{});
+      N = std::numeric_limits<int>::min();
+      current_statement__ = 13;
+      N = context__.vals_i("N")[(1 - 1)];
+      current_statement__ = 14;
+      context__.validate_dims("data initialization", "M", "int",
+        std::vector<size_t>{});
+      M = std::numeric_limits<int>::min();
+      current_statement__ = 14;
+      M = context__.vals_i("M")[(1 - 1)];
+      current_statement__ = 15;
+      stan::math::validate_non_negative_index("Idx", "N", N);
+      current_statement__ = 16;
+      context__.validate_dims("data initialization", "Idx", "int",
+        std::vector<size_t>{static_cast<size_t>(N)});
+      Idx = std::vector<int>(N, std::numeric_limits<int>::min());
+      current_statement__ = 16;
+      Idx = context__.vals_i("Idx");
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    num_params_r__ = 1 + 10;
+  }
+  inline std::string model_name() const final {
+    return "indexing2_model";
+  }
+  inline std::vector<std::string> model_compile_info() const noexcept {
+    return std::vector<std::string>{"stanc_version = %%NAME%%3 %%VERSION%%",
+             "stancflags = --use-opencl --print-cpp"};
+  }
+  // Base log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_not_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "indexing2_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      local_scalar_t__ alpha = DUMMY_VAR__;
+      current_statement__ = 1;
+      alpha = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_loop_single_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(10, DUMMY_VAR__);
+      current_statement__ = 2;
+      p_aos_loop_single_idx = in__.template read<
+                                Eigen::Matrix<local_scalar_t__,-1,1>>(10);
+      {
+        current_statement__ = 3;
+        stan::math::validate_non_negative_index(
+          "tp_soa_multi_idx_assign_in_loop", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1>
+          tp_soa_multi_idx_assign_in_loop =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 4;
+        stan::model::assign(tp_soa_multi_idx_assign_in_loop,
+          stan::math::rep_vector(alpha, N),
+          "assigning variable tp_soa_multi_idx_assign_in_loop");
+        current_statement__ = 7;
+        for (int i = 1; i <= 10; ++i) {
+          current_statement__ = 5;
+          stan::model::assign(tp_soa_multi_idx_assign_in_loop,
+            stan::math::multiply(
+              stan::model::deep_copy(tp_soa_multi_idx_assign_in_loop),
+              stan::model::rvalue(p_aos_loop_single_idx,
+                "p_aos_loop_single_idx", stan::model::index_uni(i))),
+            "assigning variable tp_soa_multi_idx_assign_in_loop");
+        }
+        current_statement__ = 8;
+        stan::math::validate_non_negative_index(
+          "tp_soa_single_idx_in_upfrom_idx", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1>
+          tp_soa_single_idx_in_upfrom_idx =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 12;
+        for (int i = 1; i <= 5; ++i) {
+          current_statement__ = 10;
+          stan::model::assign(tp_soa_single_idx_in_upfrom_idx,
+            stan::model::rvalue(tp_soa_multi_idx_assign_in_loop,
+              "tp_soa_multi_idx_assign_in_loop",
+              stan::model::index_min(
+                stan::model::rvalue(Idx, "Idx", stan::model::index_uni(i)))),
+            "assigning variable tp_soa_single_idx_in_upfrom_idx");
+        }
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  // Reverse mode autodiff log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "indexing2_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      local_scalar_t__ alpha = DUMMY_VAR__;
+      current_statement__ = 1;
+      alpha = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_loop_single_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(10, DUMMY_VAR__);
+      current_statement__ = 2;
+      p_aos_loop_single_idx = in__.template read<
+                                Eigen::Matrix<local_scalar_t__,-1,1>>(10);
+      {
+        current_statement__ = 3;
+        stan::math::validate_non_negative_index(
+          "tp_soa_multi_idx_assign_in_loop", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1>
+          tp_soa_multi_idx_assign_in_loop =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 4;
+        stan::model::assign(tp_soa_multi_idx_assign_in_loop,
+          stan::math::rep_vector(alpha, N),
+          "assigning variable tp_soa_multi_idx_assign_in_loop");
+        current_statement__ = 7;
+        for (int i = 1; i <= 10; ++i) {
+          current_statement__ = 5;
+          stan::model::assign(tp_soa_multi_idx_assign_in_loop,
+            stan::math::multiply(
+              stan::model::deep_copy(tp_soa_multi_idx_assign_in_loop),
+              stan::model::rvalue(p_aos_loop_single_idx,
+                "p_aos_loop_single_idx", stan::model::index_uni(i))),
+            "assigning variable tp_soa_multi_idx_assign_in_loop");
+        }
+        current_statement__ = 8;
+        stan::math::validate_non_negative_index(
+          "tp_soa_single_idx_in_upfrom_idx", "N", N);
+        Eigen::Matrix<local_scalar_t__,-1,1>
+          tp_soa_single_idx_in_upfrom_idx =
+          Eigen::Matrix<local_scalar_t__,-1,1>::Constant(N, DUMMY_VAR__);
+        current_statement__ = 12;
+        for (int i = 1; i <= 5; ++i) {
+          current_statement__ = 10;
+          stan::model::assign(tp_soa_single_idx_in_upfrom_idx,
+            stan::model::rvalue(tp_soa_multi_idx_assign_in_loop,
+              "tp_soa_multi_idx_assign_in_loop",
+              stan::model::index_min(
+                stan::model::rvalue(Idx, "Idx", stan::model::index_uni(i)))),
+            "assigning variable tp_soa_single_idx_in_upfrom_idx");
+        }
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  template <typename RNG, typename VecR, typename VecI, typename VecVar,
+            stan::require_vector_like_vt<std::is_floating_point,
+            VecR>* = nullptr, stan::require_vector_like_vt<std::is_integral,
+            VecI>* = nullptr, stan::require_vector_vt<std::is_floating_point,
+            VecVar>* = nullptr>
+  inline void
+  write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__,
+                   VecVar& vars__, const bool
+                   emit_transformed_parameters__ = true, const bool
+                   emit_generated_quantities__ = true, std::ostream*
+                   pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    static constexpr bool propto__ = true;
+    // suppress unused var warning
+    (void) propto__;
+    double lp__ = 0.0;
+    // suppress unused var warning
+    (void) lp__;
+    int current_statement__ = 0;
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    constexpr bool jacobian__ = false;
+    // suppress unused var warning
+    (void) jacobian__;
+    static constexpr const char* function__ =
+      "indexing2_model_namespace::write_array";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      double alpha = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 1;
+      alpha = in__.template read<local_scalar_t__>();
+      Eigen::Matrix<double,-1,1> p_aos_loop_single_idx =
+        Eigen::Matrix<double,-1,1>::Constant(10,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 2;
+      p_aos_loop_single_idx = in__.template read<
+                                Eigen::Matrix<local_scalar_t__,-1,1>>(10);
+      out__.write(alpha);
+      out__.write(p_aos_loop_single_idx);
+      if (stan::math::logical_negation(
+            (stan::math::primitive_value(emit_transformed_parameters__) ||
+            stan::math::primitive_value(emit_generated_quantities__)))) {
+        return ;
+      }
+      if (stan::math::logical_negation(emit_generated_quantities__)) {
+        return ;
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, typename VecI,
+            stan::require_vector_t<VecVar>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr>
+  inline void
+  unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__,
+                         VecVar& vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      local_scalar_t__ alpha = DUMMY_VAR__;
+      current_statement__ = 1;
+      alpha = in__.read<local_scalar_t__>();
+      out__.write(alpha);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_loop_single_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(10, DUMMY_VAR__);
+      current_statement__ = 2;
+      stan::model::assign(p_aos_loop_single_idx,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,1>>(10),
+        "assigning variable p_aos_loop_single_idx");
+      out__.write(p_aos_loop_single_idx);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, stan::require_vector_t<VecVar>* = nullptr>
+  inline void
+  transform_inits_impl(const stan::io::var_context& context__, VecVar&
+                       vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 1;
+      context__.validate_dims("parameter initialization", "alpha", "double",
+        std::vector<size_t>{});
+      current_statement__ = 2;
+      context__.validate_dims("parameter initialization",
+        "p_aos_loop_single_idx", "double",
+        std::vector<size_t>{static_cast<size_t>(10)});
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      local_scalar_t__ alpha = DUMMY_VAR__;
+      current_statement__ = 1;
+      alpha = context__.vals_r("alpha")[(1 - 1)];
+      out__.write(alpha);
+      Eigen::Matrix<local_scalar_t__,-1,1> p_aos_loop_single_idx =
+        Eigen::Matrix<local_scalar_t__,-1,1>::Constant(10, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> p_aos_loop_single_idx_flat__;
+        current_statement__ = 2;
+        p_aos_loop_single_idx_flat__ = context__.vals_r("p_aos_loop_single_idx");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+          stan::model::assign(p_aos_loop_single_idx,
+            p_aos_loop_single_idx_flat__[(pos__ - 1)],
+            "assigning variable p_aos_loop_single_idx",
+            stan::model::index_uni(sym1__));
+          pos__ = (pos__ + 1);
+        }
+      }
+      out__.write(p_aos_loop_single_idx);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  inline void
+  get_param_names(std::vector<std::string>& names__, const bool
+                  emit_transformed_parameters__ = true, const bool
+                  emit_generated_quantities__ = true) const {
+    names__ = std::vector<std::string>{"alpha", "p_aos_loop_single_idx"};
+    if (emit_transformed_parameters__) {}
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  get_dims(std::vector<std::vector<size_t>>& dimss__, const bool
+           emit_transformed_parameters__ = true, const bool
+           emit_generated_quantities__ = true) const {
+    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{},
+                std::vector<size_t>{static_cast<size_t>(10)}};
+    if (emit_transformed_parameters__) {}
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  constrained_param_names(std::vector<std::string>& param_names__, bool
+                          emit_transformed_parameters__ = true, bool
+                          emit_generated_quantities__ = true) const final {
+    param_names__.emplace_back(std::string() + "alpha");
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_aos_loop_single_idx" +
+        '.' + std::to_string(sym1__));
+    }
+    if (emit_transformed_parameters__) {}
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  unconstrained_param_names(std::vector<std::string>& param_names__, bool
+                            emit_transformed_parameters__ = true, bool
+                            emit_generated_quantities__ = true) const final {
+    param_names__.emplace_back(std::string() + "alpha");
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      param_names__.emplace_back(std::string() + "p_aos_loop_single_idx" +
+        '.' + std::to_string(sym1__));
+    }
+    if (emit_transformed_parameters__) {}
+    if (emit_generated_quantities__) {}
+  }
+  inline std::string get_constrained_sizedtypes() const {
+    return std::string("[{\"name\":\"alpha\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"p_aos_loop_single_idx\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(10) + "},\"block\":\"parameters\"}]");
+  }
+  inline std::string get_unconstrained_sizedtypes() const {
+    return std::string("[{\"name\":\"alpha\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"p_aos_loop_single_idx\",\"type\":{\"name\":\"vector\",\"length\":" + std::to_string(10) + "},\"block\":\"parameters\"}]");
+  }
+  // Begin method overload boilerplate
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, Eigen::Matrix<double,-1,1>& params_r,
+              Eigen::Matrix<double,-1,1>& vars, const bool
+              emit_transformed_parameters = true, const bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (1 + 10);
+    const size_t num_transformed = emit_transformed_parameters * (0);
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    std::vector<int> params_i;
+    vars = Eigen::Matrix<double,-1,1>::Constant(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, std::vector<double>& params_r, std::vector<int>&
+              params_i, std::vector<double>& vars, bool
+              emit_transformed_parameters = true, bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (1 + 10);
+    const size_t num_transformed = emit_transformed_parameters * (0);
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    vars = std::vector<double>(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(Eigen::Matrix<T_,-1,1>& params_r, std::ostream* pstream = nullptr) const {
+    Eigen::Matrix<int,-1,1> params_i;
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(std::vector<T_>& params_r, std::vector<int>& params_i,
+           std::ostream* pstream = nullptr) const {
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context,
+                  Eigen::Matrix<double,-1,1>& params_r, std::ostream*
+                  pstream = nullptr) const final {
+    std::vector<double> params_r_vec(params_r.size());
+    std::vector<int> params_i;
+    transform_inits(context, params_i, params_r_vec, pstream);
+    params_r = Eigen::Map<Eigen::Matrix<double,-1,1>>(params_r_vec.data(),
+                 params_r_vec.size());
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context, std::vector<int>&
+                  params_i, std::vector<double>& vars, std::ostream*
+                  pstream__ = nullptr) const {
+    vars.resize(num_params_r__);
+    transform_inits_impl(context, vars, pstream__);
+  }
+  inline void
+  unconstrain_array(const std::vector<double>& params_constrained,
+                    std::vector<double>& params_unconstrained, std::ostream*
+                    pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = std::vector<double>(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+  inline void
+  unconstrain_array(const Eigen::Matrix<double,-1,1>& params_constrained,
+                    Eigen::Matrix<double,-1,1>& params_unconstrained,
+                    std::ostream* pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = Eigen::Matrix<double,-1,1>::Constant(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+};
+}
+using stan_model = indexing2_model_namespace::indexing2_model;
+#ifndef USING_R
+// Boilerplate
+stan::model::model_base&
+new_model(stan::io::var_context& data_context, unsigned int seed,
+          std::ostream* msg_stream) {
+  stan_model* m = new stan_model(data_context, seed, msg_stream);
+  return *m;
+}
+stan::math::profile_map& get_stan_profile_data() {
+  return indexing2_model_namespace::profiles__;
+}
+#endif
+OpenCL (Line 13) warning: Function on right hand side of assignment is not supported by SoA: tp_soa_multi_idx_assign_in_loop
+OpenCL (Line 1) warning: Right hand side contains only AoS expressions: tp_soa_single_idx_in_upfrom_idx
+  $ ../../../../../../install/default/bin/stanc --use-opencl --print-cpp reductions_allowed.stan
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace reductions_allowed_model_namespace {
+using stan::model::model_base_crtp;
+using namespace stan::math;
+stan::math::profile_map profiles__;
+static constexpr std::array<const char*, 12> locations_array__ =
+  {" (found before start of program)",
+  " (in 'reductions_allowed.stan', line 16, column 4 to column 25)",
+  " (in 'reductions_allowed.stan', line 17, column 4 to column 25)",
+  " (in 'reductions_allowed.stan', line 18, column 4 to column 25)",
+  " (in 'reductions_allowed.stan', line 22, column 4 to column 56)",
+  " (in 'reductions_allowed.stan', line 23, column 4 to column 93)",
+  " (in 'reductions_allowed.stan', line 24, column 4 to column 85)",
+  " (in 'reductions_allowed.stan', line 12, column 4 to column 16)",
+  " (in 'reductions_allowed.stan', line 3, column 8 to column 17)",
+  " (in 'reductions_allowed.stan', line 2, column 31 to line 4, column 5)",
+  " (in 'reductions_allowed.stan', line 7, column 8 to column 25)",
+  " (in 'reductions_allowed.stan', line 6, column 48 to line 8, column 5)"};
+template <typename T0__,
+          stan::require_all_t<stan::is_eigen_matrix_dynamic<T0__>,
+                              stan::is_vt_not_complex<T0__>>* = nullptr>
+Eigen::Matrix<stan::promote_args_t<stan::base_type_t<T0__>>,-1,-1>
+nono_func(const T0__& x_arg__, std::ostream* pstream__);
+template <typename T0__, typename T1__,
+          stan::require_all_t<stan::is_stan_scalar<T0__>,
+                              stan::is_eigen_matrix_dynamic<T1__>,
+                              stan::is_vt_not_complex<T1__>>* = nullptr>
+Eigen::Matrix<stan::promote_args_t<T0__, stan::base_type_t<T1__>>,-1,-1>
+okay_reduction(const T0__& sum_x, const T1__& y_arg__, std::ostream*
+               pstream__);
+template <typename T0__,
+          stan::require_all_t<stan::is_eigen_matrix_dynamic<T0__>,
+                              stan::is_vt_not_complex<T0__>>*>
+Eigen::Matrix<stan::promote_args_t<stan::base_type_t<T0__>>,-1,-1>
+nono_func(const T0__& x_arg__, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<stan::base_type_t<T0__>>;
+  int current_statement__ = 0;
+  const auto& x = stan::math::to_ref(x_arg__);
+  static constexpr bool propto__ = true;
+  // suppress unused var warning
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  // suppress unused var warning
+  (void) DUMMY_VAR__;
+  try {
+    current_statement__ = 8;
+    return x;
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+  }
+}
+template <typename T0__, typename T1__,
+          stan::require_all_t<stan::is_stan_scalar<T0__>,
+                              stan::is_eigen_matrix_dynamic<T1__>,
+                              stan::is_vt_not_complex<T1__>>*>
+Eigen::Matrix<stan::promote_args_t<T0__, stan::base_type_t<T1__>>,-1,-1>
+okay_reduction(const T0__& sum_x, const T1__& y_arg__, std::ostream*
+               pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<T0__,
+                             stan::base_type_t<T1__>>;
+  int current_statement__ = 0;
+  const auto& y = stan::math::to_ref(y_arg__);
+  static constexpr bool propto__ = true;
+  // suppress unused var warning
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  // suppress unused var warning
+  (void) DUMMY_VAR__;
+  try {
+    current_statement__ = 10;
+    return stan::math::add(sum_x, y);
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+  }
+}
+class reductions_allowed_model final : public model_base_crtp<reductions_allowed_model> {
+ private:
+  double data_r;
+ public:
+  ~reductions_allowed_model() {}
+  reductions_allowed_model(stan::io::var_context& context__, unsigned int
+                           random_seed__ = 0, std::ostream*
+                           pstream__ = nullptr) : model_base_crtp(0) {
+    int current_statement__ = 0;
+    using local_scalar_t__ = double;
+    boost::ecuyer1988 base_rng__ =
+      stan::services::util::create_rng(random_seed__, 0);
+    // suppress unused var warning
+    (void) base_rng__;
+    static constexpr const char* function__ =
+      "reductions_allowed_model_namespace::reductions_allowed_model";
+    // suppress unused var warning
+    (void) function__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 7;
+      context__.validate_dims("data initialization", "data_r", "double",
+        std::vector<size_t>{});
+      data_r = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 7;
+      data_r = context__.vals_r("data_r")[(1 - 1)];
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    num_params_r__ = (5 * 10) + (5 * 10) + (5 * 10);
+  }
+  inline std::string model_name() const final {
+    return "reductions_allowed_model";
+  }
+  inline std::vector<std::string> model_compile_info() const noexcept {
+    return std::vector<std::string>{"stanc_version = %%NAME%%3 %%VERSION%%",
+             "stancflags = --use-opencl --print-cpp"};
+  }
+  // Base log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_not_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "reductions_allowed_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> soa_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      soa_x = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5,
+                10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      aos_x = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5,
+                10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_y =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 3;
+      aos_y = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5,
+                10);
+      local_scalar_t__ tp_real_from_soa = DUMMY_VAR__;
+      current_statement__ = 4;
+      tp_real_from_soa = (stan::math::logical_gt(5, 0) ? data_r : stan::math::sum(
+                                                                    soa_x));
+      Eigen::Matrix<local_scalar_t__,-1,-1> tp_matrix_aos_from_mix =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 5;
+      stan::model::assign(tp_matrix_aos_from_mix,
+        (stan::math::logical_gt(stan::math::sum(soa_x), 0) ? stan::math::eval(
+                                                               nono_func(
+                                                                 stan::math::add(
+                                                                   aos_x,
+                                                                   aos_y),
+                                                                 pstream__)) : 
+        stan::math::eval(aos_y)), "assigning variable tp_matrix_aos_from_mix");
+      Eigen::Matrix<local_scalar_t__,-1,-1> tp_matrix_from_udf_reduced_soa =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 6;
+      stan::model::assign(tp_matrix_from_udf_reduced_soa,
+        okay_reduction(stan::math::sum(soa_x), aos_x, pstream__),
+        "assigning variable tp_matrix_from_udf_reduced_soa");
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  // Reverse mode autodiff log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "reductions_allowed_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> soa_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      soa_x = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5,
+                10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      aos_x = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5,
+                10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_y =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 3;
+      aos_y = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5,
+                10);
+      local_scalar_t__ tp_real_from_soa = DUMMY_VAR__;
+      current_statement__ = 4;
+      tp_real_from_soa = (stan::math::logical_gt(5, 0) ? data_r : stan::math::sum(
+                                                                    soa_x));
+      Eigen::Matrix<local_scalar_t__,-1,-1> tp_matrix_aos_from_mix =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 5;
+      stan::model::assign(tp_matrix_aos_from_mix,
+        (stan::math::logical_gt(stan::math::sum(soa_x), 0) ? stan::math::eval(
+                                                               nono_func(
+                                                                 stan::math::add(
+                                                                   aos_x,
+                                                                   aos_y),
+                                                                 pstream__)) : 
+        stan::math::eval(aos_y)), "assigning variable tp_matrix_aos_from_mix");
+      Eigen::Matrix<local_scalar_t__,-1,-1> tp_matrix_from_udf_reduced_soa =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 6;
+      stan::model::assign(tp_matrix_from_udf_reduced_soa,
+        okay_reduction(stan::math::sum(soa_x), aos_x, pstream__),
+        "assigning variable tp_matrix_from_udf_reduced_soa");
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  template <typename RNG, typename VecR, typename VecI, typename VecVar,
+            stan::require_vector_like_vt<std::is_floating_point,
+            VecR>* = nullptr, stan::require_vector_like_vt<std::is_integral,
+            VecI>* = nullptr, stan::require_vector_vt<std::is_floating_point,
+            VecVar>* = nullptr>
+  inline void
+  write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__,
+                   VecVar& vars__, const bool
+                   emit_transformed_parameters__ = true, const bool
+                   emit_generated_quantities__ = true, std::ostream*
+                   pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    static constexpr bool propto__ = true;
+    // suppress unused var warning
+    (void) propto__;
+    double lp__ = 0.0;
+    // suppress unused var warning
+    (void) lp__;
+    int current_statement__ = 0;
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    constexpr bool jacobian__ = false;
+    // suppress unused var warning
+    (void) jacobian__;
+    static constexpr const char* function__ =
+      "reductions_allowed_model_namespace::write_array";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<double,-1,-1> soa_x =
+        Eigen::Matrix<double,-1,-1>::Constant(5, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 1;
+      soa_x = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5,
+                10);
+      Eigen::Matrix<double,-1,-1> aos_x =
+        Eigen::Matrix<double,-1,-1>::Constant(5, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 2;
+      aos_x = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5,
+                10);
+      Eigen::Matrix<double,-1,-1> aos_y =
+        Eigen::Matrix<double,-1,-1>::Constant(5, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 3;
+      aos_y = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5,
+                10);
+      double tp_real_from_soa = std::numeric_limits<double>::quiet_NaN();
+      Eigen::Matrix<double,-1,-1> tp_matrix_aos_from_mix =
+        Eigen::Matrix<double,-1,-1>::Constant(5, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,-1> tp_matrix_from_udf_reduced_soa =
+        Eigen::Matrix<double,-1,-1>::Constant(5, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      out__.write(soa_x);
+      out__.write(aos_x);
+      out__.write(aos_y);
+      if (stan::math::logical_negation(
+            (stan::math::primitive_value(emit_transformed_parameters__) ||
+            stan::math::primitive_value(emit_generated_quantities__)))) {
+        return ;
+      }
+      current_statement__ = 4;
+      tp_real_from_soa = (stan::math::logical_gt(5, 0) ? data_r : stan::math::sum(
+                                                                    soa_x));
+      current_statement__ = 5;
+      stan::model::assign(tp_matrix_aos_from_mix,
+        (stan::math::logical_gt(stan::math::sum(soa_x), 0) ? stan::math::eval(
+                                                               nono_func(
+                                                                 stan::math::add(
+                                                                   aos_x,
+                                                                   aos_y),
+                                                                 pstream__)) : 
+        stan::math::eval(aos_y)), "assigning variable tp_matrix_aos_from_mix");
+      current_statement__ = 6;
+      stan::model::assign(tp_matrix_from_udf_reduced_soa,
+        okay_reduction(stan::math::sum(soa_x), aos_x, pstream__),
+        "assigning variable tp_matrix_from_udf_reduced_soa");
+      if (emit_transformed_parameters__) {
+        out__.write(tp_real_from_soa);
+        out__.write(tp_matrix_aos_from_mix);
+        out__.write(tp_matrix_from_udf_reduced_soa);
+      }
+      if (stan::math::logical_negation(emit_generated_quantities__)) {
+        return ;
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, typename VecI,
+            stan::require_vector_t<VecVar>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr>
+  inline void
+  unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__,
+                         VecVar& vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> soa_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      stan::model::assign(soa_x,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5, 10),
+        "assigning variable soa_x");
+      out__.write(soa_x);
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      stan::model::assign(aos_x,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5, 10),
+        "assigning variable aos_x");
+      out__.write(aos_x);
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_y =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 3;
+      stan::model::assign(aos_y,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5, 10),
+        "assigning variable aos_y");
+      out__.write(aos_y);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, stan::require_vector_t<VecVar>* = nullptr>
+  inline void
+  transform_inits_impl(const stan::io::var_context& context__, VecVar&
+                       vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 1;
+      context__.validate_dims("parameter initialization", "soa_x", "double",
+        std::vector<size_t>{static_cast<size_t>(5), static_cast<size_t>(10)});
+      current_statement__ = 2;
+      context__.validate_dims("parameter initialization", "aos_x", "double",
+        std::vector<size_t>{static_cast<size_t>(5), static_cast<size_t>(10)});
+      current_statement__ = 3;
+      context__.validate_dims("parameter initialization", "aos_y", "double",
+        std::vector<size_t>{static_cast<size_t>(5), static_cast<size_t>(10)});
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      Eigen::Matrix<local_scalar_t__,-1,-1> soa_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> soa_x_flat__;
+        current_statement__ = 1;
+        soa_x_flat__ = context__.vals_r("soa_x");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+            stan::model::assign(soa_x, soa_x_flat__[(pos__ - 1)],
+              "assigning variable soa_x", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(soa_x);
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> aos_x_flat__;
+        current_statement__ = 2;
+        aos_x_flat__ = context__.vals_r("aos_x");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+            stan::model::assign(aos_x, aos_x_flat__[(pos__ - 1)],
+              "assigning variable aos_x", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(aos_x);
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_y =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> aos_y_flat__;
+        current_statement__ = 3;
+        aos_y_flat__ = context__.vals_r("aos_y");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+            stan::model::assign(aos_y, aos_y_flat__[(pos__ - 1)],
+              "assigning variable aos_y", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(aos_y);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  inline void
+  get_param_names(std::vector<std::string>& names__, const bool
+                  emit_transformed_parameters__ = true, const bool
+                  emit_generated_quantities__ = true) const {
+    names__ = std::vector<std::string>{"soa_x", "aos_x", "aos_y"};
+    if (emit_transformed_parameters__) {
+      std::vector<std::string>
+        temp{"tp_real_from_soa", "tp_matrix_aos_from_mix",
+             "tp_matrix_from_udf_reduced_soa"};
+      names__.reserve(names__.size() + temp.size());
+      names__.insert(names__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  get_dims(std::vector<std::vector<size_t>>& dimss__, const bool
+           emit_transformed_parameters__ = true, const bool
+           emit_generated_quantities__ = true) const {
+    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{static_cast<
+                                                                    size_t>(5),
+                                                 static_cast<size_t>(10)},
+                std::vector<size_t>{static_cast<size_t>(5),
+                  static_cast<size_t>(10)},
+                std::vector<size_t>{static_cast<size_t>(5),
+                  static_cast<size_t>(10)}};
+    if (emit_transformed_parameters__) {
+      std::vector<std::vector<size_t>>
+        temp{std::vector<size_t>{},
+             std::vector<size_t>{static_cast<size_t>(5),
+               static_cast<size_t>(10)},
+             std::vector<size_t>{static_cast<size_t>(5),
+               static_cast<size_t>(10)}};
+      dimss__.reserve(dimss__.size() + temp.size());
+      dimss__.insert(dimss__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  constrained_param_names(std::vector<std::string>& param_names__, bool
+                          emit_transformed_parameters__ = true, bool
+                          emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+        param_names__.emplace_back(std::string() + "soa_x" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+        param_names__.emplace_back(std::string() + "aos_x" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+        param_names__.emplace_back(std::string() + "aos_y" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      param_names__.emplace_back(std::string() + "tp_real_from_soa");
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+          param_names__.emplace_back(std::string() + "tp_matrix_aos_from_mix"
+            + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+          param_names__.emplace_back(std::string() +
+            "tp_matrix_from_udf_reduced_soa" + '.' + std::to_string(sym2__) +
+            '.' + std::to_string(sym1__));
+        }
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  unconstrained_param_names(std::vector<std::string>& param_names__, bool
+                            emit_transformed_parameters__ = true, bool
+                            emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+        param_names__.emplace_back(std::string() + "soa_x" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+        param_names__.emplace_back(std::string() + "aos_x" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+        param_names__.emplace_back(std::string() + "aos_y" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      param_names__.emplace_back(std::string() + "tp_real_from_soa");
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+          param_names__.emplace_back(std::string() + "tp_matrix_aos_from_mix"
+            + '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+          param_names__.emplace_back(std::string() +
+            "tp_matrix_from_udf_reduced_soa" + '.' + std::to_string(sym2__) +
+            '.' + std::to_string(sym1__));
+        }
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline std::string get_constrained_sizedtypes() const {
+    return std::string("[{\"name\":\"soa_x\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"aos_x\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"aos_y\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"tp_real_from_soa\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"tp_matrix_aos_from_mix\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"tp_matrix_from_udf_reduced_soa\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  inline std::string get_unconstrained_sizedtypes() const {
+    return std::string("[{\"name\":\"soa_x\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"aos_x\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"aos_y\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"tp_real_from_soa\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"tp_matrix_aos_from_mix\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"tp_matrix_from_udf_reduced_soa\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  // Begin method overload boilerplate
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, Eigen::Matrix<double,-1,1>& params_r,
+              Eigen::Matrix<double,-1,1>& vars, const bool
+              emit_transformed_parameters = true, const bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (((5 * 10) + (5 * 10)) + (5 * 10));
+    const size_t num_transformed = emit_transformed_parameters * (((1 + (5 *
+      10)) + (5 * 10)));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    std::vector<int> params_i;
+    vars = Eigen::Matrix<double,-1,1>::Constant(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, std::vector<double>& params_r, std::vector<int>&
+              params_i, std::vector<double>& vars, bool
+              emit_transformed_parameters = true, bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (((5 * 10) + (5 * 10)) + (5 * 10));
+    const size_t num_transformed = emit_transformed_parameters * (((1 + (5 *
+      10)) + (5 * 10)));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    vars = std::vector<double>(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(Eigen::Matrix<T_,-1,1>& params_r, std::ostream* pstream = nullptr) const {
+    Eigen::Matrix<int,-1,1> params_i;
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(std::vector<T_>& params_r, std::vector<int>& params_i,
+           std::ostream* pstream = nullptr) const {
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context,
+                  Eigen::Matrix<double,-1,1>& params_r, std::ostream*
+                  pstream = nullptr) const final {
+    std::vector<double> params_r_vec(params_r.size());
+    std::vector<int> params_i;
+    transform_inits(context, params_i, params_r_vec, pstream);
+    params_r = Eigen::Map<Eigen::Matrix<double,-1,1>>(params_r_vec.data(),
+                 params_r_vec.size());
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context, std::vector<int>&
+                  params_i, std::vector<double>& vars, std::ostream*
+                  pstream__ = nullptr) const {
+    vars.resize(num_params_r__);
+    transform_inits_impl(context, vars, pstream__);
+  }
+  inline void
+  unconstrain_array(const std::vector<double>& params_constrained,
+                    std::vector<double>& params_unconstrained, std::ostream*
+                    pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = std::vector<double>(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+  inline void
+  unconstrain_array(const Eigen::Matrix<double,-1,1>& params_constrained,
+                    Eigen::Matrix<double,-1,1>& params_unconstrained,
+                    std::ostream* pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = Eigen::Matrix<double,-1,1>::Constant(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+};
+}
+using stan_model = reductions_allowed_model_namespace::reductions_allowed_model;
+#ifndef USING_R
+// Boilerplate
+stan::model::model_base&
+new_model(stan::io::var_context& data_context, unsigned int seed,
+          std::ostream* msg_stream) {
+  stan_model* m = new stan_model(data_context, seed, msg_stream);
+  return *m;
+}
+stan::math::profile_map& get_stan_profile_data() {
+  return reductions_allowed_model_namespace::profiles__;
+}
+#endif
+OpenCL (Line 23) warning: Right hand side of assignment is all AoS: aos_x, aos_y, tp_matrix_aos_from_mix
+OpenCL (Line 24) warning: Used in user defined function:aos_x, aos_y, tp_matrix_aos_from_mix
+OpenCL (Line 24) warning: Right hand side of assignment is all AoS: aos_x, tp_matrix_from_udf_reduced_soa
+OpenCL (Line 24) warning: Function on right hand side of assignment is not supported by SoA: aos_x, tp_matrix_from_udf_reduced_soa
+  $ ../../../../../../install/default/bin/stanc --use-opencl --print-cpp return_types_and_udfs_demotes.stan
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace return_types_and_udfs_demotes_model_namespace {
+using stan::model::model_base_crtp;
+using namespace stan::math;
+stan::math::profile_map profiles__;
+static constexpr std::array<const char*, 13> locations_array__ =
+  {" (found before start of program)",
+  " (in 'return_types_and_udfs_demotes.stan', line 20, column 4 to column 27)",
+  " (in 'return_types_and_udfs_demotes.stan', line 21, column 4 to column 33)",
+  " (in 'return_types_and_udfs_demotes.stan', line 25, column 4 to column 68)",
+  " (in 'return_types_and_udfs_demotes.stan', line 26, column 4 to column 59)",
+  " (in 'return_types_and_udfs_demotes.stan', line 27, column 4 to column 90)",
+  " (in 'return_types_and_udfs_demotes.stan', line 28, column 4 to column 73)",
+  " (in 'return_types_and_udfs_demotes.stan', line 29, column 4 to column 92)",
+  " (in 'return_types_and_udfs_demotes.stan', line 11, column 8 to column 32)",
+  " (in 'return_types_and_udfs_demotes.stan', line 12, column 8 to column 24)",
+  " (in 'return_types_and_udfs_demotes.stan', line 10, column 29 to line 13, column 5)",
+  " (in 'return_types_and_udfs_demotes.stan', line 15, column 8 to column 17)",
+  " (in 'return_types_and_udfs_demotes.stan', line 14, column 39 to line 16, column 5)"};
+Eigen::Matrix<double,-1,-1> empty_user_func(std::ostream* pstream__);
+template <typename T0__,
+          stan::require_all_t<stan::is_eigen_matrix_dynamic<T0__>,
+                              stan::is_vt_not_complex<T0__>>* = nullptr>
+Eigen::Matrix<stan::promote_args_t<stan::base_type_t<T0__>>,-1,-1>
+mat_ret_user_func(const T0__& A_arg__, std::ostream* pstream__);
+Eigen::Matrix<double,-1,-1> empty_user_func(std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  int current_statement__ = 0;
+  static constexpr bool propto__ = true;
+  // suppress unused var warning
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  // suppress unused var warning
+  (void) DUMMY_VAR__;
+  try {
+    Eigen::Matrix<local_scalar_t__,-1,-1> some_mat =
+      Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+    current_statement__ = 9;
+    return some_mat;
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+  }
+}
+template <typename T0__,
+          stan::require_all_t<stan::is_eigen_matrix_dynamic<T0__>,
+                              stan::is_vt_not_complex<T0__>>*>
+Eigen::Matrix<stan::promote_args_t<stan::base_type_t<T0__>>,-1,-1>
+mat_ret_user_func(const T0__& A_arg__, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<stan::base_type_t<T0__>>;
+  int current_statement__ = 0;
+  const auto& A = stan::math::to_ref(A_arg__);
+  static constexpr bool propto__ = true;
+  // suppress unused var warning
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  // suppress unused var warning
+  (void) DUMMY_VAR__;
+  try {
+    current_statement__ = 11;
+    return A;
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+  }
+}
+class return_types_and_udfs_demotes_model final : public model_base_crtp<return_types_and_udfs_demotes_model> {
+ private:
+  
+ public:
+  ~return_types_and_udfs_demotes_model() {}
+  return_types_and_udfs_demotes_model(stan::io::var_context& context__,
+                                      unsigned int random_seed__ = 0,
+                                      std::ostream* pstream__ = nullptr)
+      : model_base_crtp(0) {
+    int current_statement__ = 0;
+    using local_scalar_t__ = double;
+    boost::ecuyer1988 base_rng__ =
+      stan::services::util::create_rng(random_seed__, 0);
+    // suppress unused var warning
+    (void) base_rng__;
+    static constexpr const char* function__ =
+      "return_types_and_udfs_demotes_model_namespace::return_types_and_udfs_demotes_model";
+    // suppress unused var warning
+    (void) function__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    num_params_r__ = (10 * 10) + (10 * 10);
+  }
+  inline std::string model_name() const final {
+    return "return_types_and_udfs_demotes_model";
+  }
+  inline std::vector<std::string> model_compile_info() const noexcept {
+    return std::vector<std::string>{"stanc_version = %%NAME%%3 %%VERSION%%",
+             "stancflags = --use-opencl --print-cpp"};
+  }
+  // Base log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_not_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "return_types_and_udfs_demotes_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> row_soa =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      row_soa = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10,
+                  10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> udf_input_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      udf_input_aos = in__.template read<
+                        Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> user_func_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 3;
+      stan::model::assign(user_func_aos,
+        mat_ret_user_func(udf_input_aos, pstream__),
+        "assigning variable user_func_aos");
+      Eigen::Matrix<local_scalar_t__,-1,-1> empty_user_func_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 4;
+      stan::model::assign(empty_user_func_aos, empty_user_func(pstream__),
+        "assigning variable empty_user_func_aos");
+      Eigen::Matrix<local_scalar_t__,-1,-1> inner_empty_user_func_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 5;
+      stan::model::assign(inner_empty_user_func_aos,
+        stan::math::multiply(udf_input_aos, empty_user_func(pstream__)),
+        "assigning variable inner_empty_user_func_aos");
+      Eigen::Matrix<local_scalar_t__,-1,-1> int_aos_mul_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 6;
+      stan::model::assign(int_aos_mul_aos,
+        stan::math::multiply(stan::math::rows(row_soa), empty_user_func_aos),
+        "assigning variable int_aos_mul_aos");
+      Eigen::Matrix<local_scalar_t__,-1,-1> mul_two_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 7;
+      stan::model::assign(mul_two_aos,
+        stan::math::multiply(
+          stan::math::multiply(stan::math::cols(row_soa),
+            stan::math::transpose(int_aos_mul_aos)), user_func_aos),
+        "assigning variable mul_two_aos");
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  // Reverse mode autodiff log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "return_types_and_udfs_demotes_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> row_soa =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      row_soa = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10,
+                  10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> udf_input_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      udf_input_aos = in__.template read<
+                        Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> user_func_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 3;
+      stan::model::assign(user_func_aos,
+        mat_ret_user_func(udf_input_aos, pstream__),
+        "assigning variable user_func_aos");
+      Eigen::Matrix<local_scalar_t__,-1,-1> empty_user_func_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 4;
+      stan::model::assign(empty_user_func_aos, empty_user_func(pstream__),
+        "assigning variable empty_user_func_aos");
+      Eigen::Matrix<local_scalar_t__,-1,-1> inner_empty_user_func_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 5;
+      stan::model::assign(inner_empty_user_func_aos,
+        stan::math::multiply(udf_input_aos, empty_user_func(pstream__)),
+        "assigning variable inner_empty_user_func_aos");
+      Eigen::Matrix<local_scalar_t__,-1,-1> int_aos_mul_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 6;
+      stan::model::assign(int_aos_mul_aos,
+        stan::math::multiply(stan::math::rows(row_soa), empty_user_func_aos),
+        "assigning variable int_aos_mul_aos");
+      Eigen::Matrix<local_scalar_t__,-1,-1> mul_two_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 7;
+      stan::model::assign(mul_two_aos,
+        stan::math::multiply(
+          stan::math::multiply(stan::math::cols(row_soa),
+            stan::math::transpose(int_aos_mul_aos)), user_func_aos),
+        "assigning variable mul_two_aos");
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  template <typename RNG, typename VecR, typename VecI, typename VecVar,
+            stan::require_vector_like_vt<std::is_floating_point,
+            VecR>* = nullptr, stan::require_vector_like_vt<std::is_integral,
+            VecI>* = nullptr, stan::require_vector_vt<std::is_floating_point,
+            VecVar>* = nullptr>
+  inline void
+  write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__,
+                   VecVar& vars__, const bool
+                   emit_transformed_parameters__ = true, const bool
+                   emit_generated_quantities__ = true, std::ostream*
+                   pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    static constexpr bool propto__ = true;
+    // suppress unused var warning
+    (void) propto__;
+    double lp__ = 0.0;
+    // suppress unused var warning
+    (void) lp__;
+    int current_statement__ = 0;
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    constexpr bool jacobian__ = false;
+    // suppress unused var warning
+    (void) jacobian__;
+    static constexpr const char* function__ =
+      "return_types_and_udfs_demotes_model_namespace::write_array";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<double,-1,-1> row_soa =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 1;
+      row_soa = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10,
+                  10);
+      Eigen::Matrix<double,-1,-1> udf_input_aos =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 2;
+      udf_input_aos = in__.template read<
+                        Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10);
+      Eigen::Matrix<double,-1,-1> user_func_aos =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,-1> empty_user_func_aos =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,-1> inner_empty_user_func_aos =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,-1> int_aos_mul_aos =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      Eigen::Matrix<double,-1,-1> mul_two_aos =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      out__.write(row_soa);
+      out__.write(udf_input_aos);
+      if (stan::math::logical_negation(
+            (stan::math::primitive_value(emit_transformed_parameters__) ||
+            stan::math::primitive_value(emit_generated_quantities__)))) {
+        return ;
+      }
+      current_statement__ = 3;
+      stan::model::assign(user_func_aos,
+        mat_ret_user_func(udf_input_aos, pstream__),
+        "assigning variable user_func_aos");
+      current_statement__ = 4;
+      stan::model::assign(empty_user_func_aos, empty_user_func(pstream__),
+        "assigning variable empty_user_func_aos");
+      current_statement__ = 5;
+      stan::model::assign(inner_empty_user_func_aos,
+        stan::math::multiply(udf_input_aos, empty_user_func(pstream__)),
+        "assigning variable inner_empty_user_func_aos");
+      current_statement__ = 6;
+      stan::model::assign(int_aos_mul_aos,
+        stan::math::multiply(stan::math::rows(row_soa), empty_user_func_aos),
+        "assigning variable int_aos_mul_aos");
+      current_statement__ = 7;
+      stan::model::assign(mul_two_aos,
+        stan::math::multiply(
+          stan::math::multiply(stan::math::cols(row_soa),
+            stan::math::transpose(int_aos_mul_aos)), user_func_aos),
+        "assigning variable mul_two_aos");
+      if (emit_transformed_parameters__) {
+        out__.write(user_func_aos);
+        out__.write(empty_user_func_aos);
+        out__.write(inner_empty_user_func_aos);
+        out__.write(int_aos_mul_aos);
+        out__.write(mul_two_aos);
+      }
+      if (stan::math::logical_negation(emit_generated_quantities__)) {
+        return ;
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, typename VecI,
+            stan::require_vector_t<VecVar>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr>
+  inline void
+  unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__,
+                         VecVar& vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> row_soa =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      stan::model::assign(row_soa,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10),
+        "assigning variable row_soa");
+      out__.write(row_soa);
+      Eigen::Matrix<local_scalar_t__,-1,-1> udf_input_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      stan::model::assign(udf_input_aos,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10),
+        "assigning variable udf_input_aos");
+      out__.write(udf_input_aos);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, stan::require_vector_t<VecVar>* = nullptr>
+  inline void
+  transform_inits_impl(const stan::io::var_context& context__, VecVar&
+                       vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 1;
+      context__.validate_dims("parameter initialization", "row_soa",
+        "double",
+        std::vector<size_t>{static_cast<size_t>(10), static_cast<size_t>(10)});
+      current_statement__ = 2;
+      context__.validate_dims("parameter initialization", "udf_input_aos",
+        "double",
+        std::vector<size_t>{static_cast<size_t>(10), static_cast<size_t>(10)});
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      Eigen::Matrix<local_scalar_t__,-1,-1> row_soa =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> row_soa_flat__;
+        current_statement__ = 1;
+        row_soa_flat__ = context__.vals_r("row_soa");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+            stan::model::assign(row_soa, row_soa_flat__[(pos__ - 1)],
+              "assigning variable row_soa", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(row_soa);
+      Eigen::Matrix<local_scalar_t__,-1,-1> udf_input_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> udf_input_aos_flat__;
+        current_statement__ = 2;
+        udf_input_aos_flat__ = context__.vals_r("udf_input_aos");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+            stan::model::assign(udf_input_aos, udf_input_aos_flat__[(pos__ -
+              1)], "assigning variable udf_input_aos",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(udf_input_aos);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  inline void
+  get_param_names(std::vector<std::string>& names__, const bool
+                  emit_transformed_parameters__ = true, const bool
+                  emit_generated_quantities__ = true) const {
+    names__ = std::vector<std::string>{"row_soa", "udf_input_aos"};
+    if (emit_transformed_parameters__) {
+      std::vector<std::string>
+        temp{"user_func_aos", "empty_user_func_aos",
+             "inner_empty_user_func_aos", "int_aos_mul_aos", "mul_two_aos"};
+      names__.reserve(names__.size() + temp.size());
+      names__.insert(names__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  get_dims(std::vector<std::vector<size_t>>& dimss__, const bool
+           emit_transformed_parameters__ = true, const bool
+           emit_generated_quantities__ = true) const {
+    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{static_cast<
+                                                                    size_t>(
+                                                                    10),
+                                                 static_cast<size_t>(10)},
+                std::vector<size_t>{static_cast<size_t>(10),
+                  static_cast<size_t>(10)}};
+    if (emit_transformed_parameters__) {
+      std::vector<std::vector<size_t>>
+        temp{std::vector<size_t>{static_cast<size_t>(10),
+               static_cast<size_t>(10)},
+             std::vector<size_t>{static_cast<size_t>(10),
+               static_cast<size_t>(10)},
+             std::vector<size_t>{static_cast<size_t>(10),
+               static_cast<size_t>(10)},
+             std::vector<size_t>{static_cast<size_t>(10),
+               static_cast<size_t>(10)},
+             std::vector<size_t>{static_cast<size_t>(10),
+               static_cast<size_t>(10)}};
+      dimss__.reserve(dimss__.size() + temp.size());
+      dimss__.insert(dimss__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  constrained_param_names(std::vector<std::string>& param_names__, bool
+                          emit_transformed_parameters__ = true, bool
+                          emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "row_soa" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "udf_input_aos" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "user_func_aos" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "empty_user_func_aos" +
+            '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() +
+            "inner_empty_user_func_aos" + '.' + std::to_string(sym2__) + '.'
+            + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "int_aos_mul_aos" + '.'
+            + std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "mul_two_aos" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  unconstrained_param_names(std::vector<std::string>& param_names__, bool
+                            emit_transformed_parameters__ = true, bool
+                            emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "row_soa" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "udf_input_aos" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "user_func_aos" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "empty_user_func_aos" +
+            '.' + std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() +
+            "inner_empty_user_func_aos" + '.' + std::to_string(sym2__) + '.'
+            + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "int_aos_mul_aos" + '.'
+            + std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+          param_names__.emplace_back(std::string() + "mul_two_aos" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline std::string get_constrained_sizedtypes() const {
+    return std::string("[{\"name\":\"row_soa\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"udf_input_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"user_func_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"empty_user_func_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"inner_empty_user_func_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"int_aos_mul_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"mul_two_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  inline std::string get_unconstrained_sizedtypes() const {
+    return std::string("[{\"name\":\"row_soa\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"udf_input_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"user_func_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"empty_user_func_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"inner_empty_user_func_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"int_aos_mul_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"},{\"name\":\"mul_two_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  // Begin method overload boilerplate
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, Eigen::Matrix<double,-1,1>& params_r,
+              Eigen::Matrix<double,-1,1>& vars, const bool
+              emit_transformed_parameters = true, const bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = ((10 * 10) + (10 * 10));
+    const size_t num_transformed = emit_transformed_parameters * ((((((10 *
+      10) + (10 * 10)) + (10 * 10)) + (10 * 10)) + (10 * 10)));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    std::vector<int> params_i;
+    vars = Eigen::Matrix<double,-1,1>::Constant(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, std::vector<double>& params_r, std::vector<int>&
+              params_i, std::vector<double>& vars, bool
+              emit_transformed_parameters = true, bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = ((10 * 10) + (10 * 10));
+    const size_t num_transformed = emit_transformed_parameters * ((((((10 *
+      10) + (10 * 10)) + (10 * 10)) + (10 * 10)) + (10 * 10)));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    vars = std::vector<double>(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(Eigen::Matrix<T_,-1,1>& params_r, std::ostream* pstream = nullptr) const {
+    Eigen::Matrix<int,-1,1> params_i;
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(std::vector<T_>& params_r, std::vector<int>& params_i,
+           std::ostream* pstream = nullptr) const {
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context,
+                  Eigen::Matrix<double,-1,1>& params_r, std::ostream*
+                  pstream = nullptr) const final {
+    std::vector<double> params_r_vec(params_r.size());
+    std::vector<int> params_i;
+    transform_inits(context, params_i, params_r_vec, pstream);
+    params_r = Eigen::Map<Eigen::Matrix<double,-1,1>>(params_r_vec.data(),
+                 params_r_vec.size());
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context, std::vector<int>&
+                  params_i, std::vector<double>& vars, std::ostream*
+                  pstream__ = nullptr) const {
+    vars.resize(num_params_r__);
+    transform_inits_impl(context, vars, pstream__);
+  }
+  inline void
+  unconstrain_array(const std::vector<double>& params_constrained,
+                    std::vector<double>& params_unconstrained, std::ostream*
+                    pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = std::vector<double>(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+  inline void
+  unconstrain_array(const Eigen::Matrix<double,-1,1>& params_constrained,
+                    Eigen::Matrix<double,-1,1>& params_unconstrained,
+                    std::ostream* pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = Eigen::Matrix<double,-1,1>::Constant(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+};
+}
+using stan_model = return_types_and_udfs_demotes_model_namespace::return_types_and_udfs_demotes_model;
+#ifndef USING_R
+// Boilerplate
+stan::model::model_base&
+new_model(stan::io::var_context& data_context, unsigned int seed,
+          std::ostream* msg_stream) {
+  stan_model* m = new stan_model(data_context, seed, msg_stream);
+  return *m;
+}
+stan::math::profile_map& get_stan_profile_data() {
+  return return_types_and_udfs_demotes_model_namespace::profiles__;
+}
+#endif
+OpenCL (Line 25) warning: Right hand side of assignment is all AoS: udf_input_aos, user_func_aos
+OpenCL (Line 25) warning: Function on right hand side of assignment is not supported by SoA: udf_input_aos, user_func_aos
+OpenCL (Line 26) warning: Used in user defined function:udf_input_aos, user_func_aos
+OpenCL (Line 26) warning: Function on right hand side of assignment is not supported by SoA: empty_user_func_aos
+OpenCL (Line 27) warning: Used in user defined function:empty_user_func_aos, udf_input_aos, user_func_aos
+OpenCL (Line 27) warning: Right hand side of assignment is all AoS: inner_empty_user_func_aos, udf_input_aos
+OpenCL (Line 28) warning: Right hand side of assignment is all AoS: empty_user_func_aos, int_aos_mul_aos
+OpenCL (Line 29) warning: Function cols is not supported: row_soa
+OpenCL (Line 29) warning: Right hand side of assignment is all AoS: int_aos_mul_aos, mul_two_aos, user_func_aos
+  $ ../../../../../../install/default/bin/stanc --use-opencl --print-cpp single_indexing.stan
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace single_indexing_model_namespace {
+using stan::model::model_base_crtp;
+using namespace stan::math;
+stan::math::profile_map profiles__;
+static constexpr std::array<const char*, 8> locations_array__ =
+  {" (found before start of program)",
+  " (in 'single_indexing.stan', line 6, column 3 to column 24)",
+  " (in 'single_indexing.stan', line 7, column 3 to column 24)",
+  " (in 'single_indexing.stan', line 11, column 5 to column 41)",
+  " (in 'single_indexing.stan', line 14, column 7 to column 78)",
+  " (in 'single_indexing.stan', line 16, column 7 to column 77)",
+  " (in 'single_indexing.stan', line 12, column 21 to line 17, column 6)",
+  " (in 'single_indexing.stan', line 12, column 5 to line 17, column 6)"};
+class single_indexing_model final : public model_base_crtp<single_indexing_model> {
+ private:
+  
+ public:
+  ~single_indexing_model() {}
+  single_indexing_model(stan::io::var_context& context__, unsigned int
+                        random_seed__ = 0, std::ostream* pstream__ = nullptr)
+      : model_base_crtp(0) {
+    int current_statement__ = 0;
+    using local_scalar_t__ = double;
+    boost::ecuyer1988 base_rng__ =
+      stan::services::util::create_rng(random_seed__, 0);
+    // suppress unused var warning
+    (void) base_rng__;
+    static constexpr const char* function__ =
+      "single_indexing_model_namespace::single_indexing_model";
+    // suppress unused var warning
+    (void) function__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    num_params_r__ = (10 * 10) + (10 * 10);
+  }
+  inline std::string model_name() const final {
+    return "single_indexing_model";
+  }
+  inline std::vector<std::string> model_compile_info() const noexcept {
+    return std::vector<std::string>{"stanc_version = %%NAME%%3 %%VERSION%%",
+             "stancflags = --use-opencl --print-cpp"};
+  }
+  // Base log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_not_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "single_indexing_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      aos_p = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10,
+                10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> soa_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      soa_p = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10,
+                10);
+      local_scalar_t__ tp_real_from_soa = DUMMY_VAR__;
+      current_statement__ = 3;
+      tp_real_from_soa = stan::model::rvalue(soa_p, "soa_p",
+                           stan::model::index_uni(1),
+                           stan::model::index_uni(1));
+      current_statement__ = 7;
+      for (int i = 1; i <= 10; ++i) {
+        Eigen::Matrix<local_scalar_t__,1,-1> tp_row_vector_from_soa_loop =
+          Eigen::Matrix<local_scalar_t__,1,-1>::Constant(10, DUMMY_VAR__);
+        current_statement__ = 4;
+        stan::model::assign(tp_row_vector_from_soa_loop,
+          stan::math::multiply(
+            stan::model::rvalue(soa_p, "soa_p", stan::model::index_uni(i)),
+            soa_p), "assigning variable tp_row_vector_from_soa_loop");
+        Eigen::Matrix<local_scalar_t__,-1,-1> tp_matrix_from_soa_loop =
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10,
+            DUMMY_VAR__);
+        current_statement__ = 5;
+        stan::model::assign(tp_matrix_from_soa_loop,
+          stan::math::multiply(
+            stan::model::rvalue(aos_p, "aos_p", stan::model::index_uni(i),
+              stan::model::index_uni(i)), soa_p),
+          "assigning variable tp_matrix_from_soa_loop");
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  // Reverse mode autodiff log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "single_indexing_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      aos_p = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10,
+                10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> soa_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      soa_p = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10,
+                10);
+      local_scalar_t__ tp_real_from_soa = DUMMY_VAR__;
+      current_statement__ = 3;
+      tp_real_from_soa = stan::model::rvalue(soa_p, "soa_p",
+                           stan::model::index_uni(1),
+                           stan::model::index_uni(1));
+      current_statement__ = 7;
+      for (int i = 1; i <= 10; ++i) {
+        Eigen::Matrix<local_scalar_t__,1,-1> tp_row_vector_from_soa_loop =
+          Eigen::Matrix<local_scalar_t__,1,-1>::Constant(10, DUMMY_VAR__);
+        current_statement__ = 4;
+        stan::model::assign(tp_row_vector_from_soa_loop,
+          stan::math::multiply(
+            stan::model::rvalue(soa_p, "soa_p", stan::model::index_uni(i)),
+            soa_p), "assigning variable tp_row_vector_from_soa_loop");
+        Eigen::Matrix<local_scalar_t__,-1,-1> tp_matrix_from_soa_loop =
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10,
+            DUMMY_VAR__);
+        current_statement__ = 5;
+        stan::model::assign(tp_matrix_from_soa_loop,
+          stan::math::multiply(
+            stan::model::rvalue(aos_p, "aos_p", stan::model::index_uni(i),
+              stan::model::index_uni(i)), soa_p),
+          "assigning variable tp_matrix_from_soa_loop");
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  template <typename RNG, typename VecR, typename VecI, typename VecVar,
+            stan::require_vector_like_vt<std::is_floating_point,
+            VecR>* = nullptr, stan::require_vector_like_vt<std::is_integral,
+            VecI>* = nullptr, stan::require_vector_vt<std::is_floating_point,
+            VecVar>* = nullptr>
+  inline void
+  write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__,
+                   VecVar& vars__, const bool
+                   emit_transformed_parameters__ = true, const bool
+                   emit_generated_quantities__ = true, std::ostream*
+                   pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    static constexpr bool propto__ = true;
+    // suppress unused var warning
+    (void) propto__;
+    double lp__ = 0.0;
+    // suppress unused var warning
+    (void) lp__;
+    int current_statement__ = 0;
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    constexpr bool jacobian__ = false;
+    // suppress unused var warning
+    (void) jacobian__;
+    static constexpr const char* function__ =
+      "single_indexing_model_namespace::write_array";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<double,-1,-1> aos_p =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 1;
+      aos_p = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10,
+                10);
+      Eigen::Matrix<double,-1,-1> soa_p =
+        Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 2;
+      soa_p = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10,
+                10);
+      double tp_real_from_soa = std::numeric_limits<double>::quiet_NaN();
+      out__.write(aos_p);
+      out__.write(soa_p);
+      if (stan::math::logical_negation(
+            (stan::math::primitive_value(emit_transformed_parameters__) ||
+            stan::math::primitive_value(emit_generated_quantities__)))) {
+        return ;
+      }
+      current_statement__ = 3;
+      tp_real_from_soa = stan::model::rvalue(soa_p, "soa_p",
+                           stan::model::index_uni(1),
+                           stan::model::index_uni(1));
+      current_statement__ = 7;
+      for (int i = 1; i <= 10; ++i) {
+        Eigen::Matrix<double,1,-1> tp_row_vector_from_soa_loop =
+          Eigen::Matrix<double,1,-1>::Constant(10,
+            std::numeric_limits<double>::quiet_NaN());
+        current_statement__ = 4;
+        stan::model::assign(tp_row_vector_from_soa_loop,
+          stan::math::multiply(
+            stan::model::rvalue(soa_p, "soa_p", stan::model::index_uni(i)),
+            soa_p), "assigning variable tp_row_vector_from_soa_loop");
+        Eigen::Matrix<double,-1,-1> tp_matrix_from_soa_loop =
+          Eigen::Matrix<double,-1,-1>::Constant(10, 10,
+            std::numeric_limits<double>::quiet_NaN());
+        current_statement__ = 5;
+        stan::model::assign(tp_matrix_from_soa_loop,
+          stan::math::multiply(
+            stan::model::rvalue(aos_p, "aos_p", stan::model::index_uni(i),
+              stan::model::index_uni(i)), soa_p),
+          "assigning variable tp_matrix_from_soa_loop");
+      }
+      if (emit_transformed_parameters__) {
+        out__.write(tp_real_from_soa);
+      }
+      if (stan::math::logical_negation(emit_generated_quantities__)) {
+        return ;
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, typename VecI,
+            stan::require_vector_t<VecVar>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr>
+  inline void
+  unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__,
+                         VecVar& vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      stan::model::assign(aos_p,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10),
+        "assigning variable aos_p");
+      out__.write(aos_p);
+      Eigen::Matrix<local_scalar_t__,-1,-1> soa_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      stan::model::assign(soa_p,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(10, 10),
+        "assigning variable soa_p");
+      out__.write(soa_p);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, stan::require_vector_t<VecVar>* = nullptr>
+  inline void
+  transform_inits_impl(const stan::io::var_context& context__, VecVar&
+                       vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 1;
+      context__.validate_dims("parameter initialization", "aos_p", "double",
+        std::vector<size_t>{static_cast<size_t>(10), static_cast<size_t>(10)});
+      current_statement__ = 2;
+      context__.validate_dims("parameter initialization", "soa_p", "double",
+        std::vector<size_t>{static_cast<size_t>(10), static_cast<size_t>(10)});
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> aos_p_flat__;
+        current_statement__ = 1;
+        aos_p_flat__ = context__.vals_r("aos_p");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+            stan::model::assign(aos_p, aos_p_flat__[(pos__ - 1)],
+              "assigning variable aos_p", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(aos_p);
+      Eigen::Matrix<local_scalar_t__,-1,-1> soa_p =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(10, 10, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> soa_p_flat__;
+        current_statement__ = 2;
+        soa_p_flat__ = context__.vals_r("soa_p");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+            stan::model::assign(soa_p, soa_p_flat__[(pos__ - 1)],
+              "assigning variable soa_p", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(soa_p);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  inline void
+  get_param_names(std::vector<std::string>& names__, const bool
+                  emit_transformed_parameters__ = true, const bool
+                  emit_generated_quantities__ = true) const {
+    names__ = std::vector<std::string>{"aos_p", "soa_p"};
+    if (emit_transformed_parameters__) {
+      std::vector<std::string> temp{"tp_real_from_soa"};
+      names__.reserve(names__.size() + temp.size());
+      names__.insert(names__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  get_dims(std::vector<std::vector<size_t>>& dimss__, const bool
+           emit_transformed_parameters__ = true, const bool
+           emit_generated_quantities__ = true) const {
+    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{static_cast<
+                                                                    size_t>(
+                                                                    10),
+                                                 static_cast<size_t>(10)},
+                std::vector<size_t>{static_cast<size_t>(10),
+                  static_cast<size_t>(10)}};
+    if (emit_transformed_parameters__) {
+      std::vector<std::vector<size_t>> temp{std::vector<size_t>{}};
+      dimss__.reserve(dimss__.size() + temp.size());
+      dimss__.insert(dimss__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  constrained_param_names(std::vector<std::string>& param_names__, bool
+                          emit_transformed_parameters__ = true, bool
+                          emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "aos_p" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "soa_p" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      param_names__.emplace_back(std::string() + "tp_real_from_soa");
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  unconstrained_param_names(std::vector<std::string>& param_names__, bool
+                            emit_transformed_parameters__ = true, bool
+                            emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "aos_p" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 10; ++sym2__) {
+        param_names__.emplace_back(std::string() + "soa_p" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      param_names__.emplace_back(std::string() + "tp_real_from_soa");
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline std::string get_constrained_sizedtypes() const {
+    return std::string("[{\"name\":\"aos_p\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"soa_p\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"tp_real_from_soa\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]");
+  }
+  inline std::string get_unconstrained_sizedtypes() const {
+    return std::string("[{\"name\":\"aos_p\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"soa_p\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(10) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"tp_real_from_soa\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]");
+  }
+  // Begin method overload boilerplate
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, Eigen::Matrix<double,-1,1>& params_r,
+              Eigen::Matrix<double,-1,1>& vars, const bool
+              emit_transformed_parameters = true, const bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = ((10 * 10) + (10 * 10));
+    const size_t num_transformed = emit_transformed_parameters * (1);
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    std::vector<int> params_i;
+    vars = Eigen::Matrix<double,-1,1>::Constant(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, std::vector<double>& params_r, std::vector<int>&
+              params_i, std::vector<double>& vars, bool
+              emit_transformed_parameters = true, bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = ((10 * 10) + (10 * 10));
+    const size_t num_transformed = emit_transformed_parameters * (1);
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    vars = std::vector<double>(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(Eigen::Matrix<T_,-1,1>& params_r, std::ostream* pstream = nullptr) const {
+    Eigen::Matrix<int,-1,1> params_i;
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(std::vector<T_>& params_r, std::vector<int>& params_i,
+           std::ostream* pstream = nullptr) const {
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context,
+                  Eigen::Matrix<double,-1,1>& params_r, std::ostream*
+                  pstream = nullptr) const final {
+    std::vector<double> params_r_vec(params_r.size());
+    std::vector<int> params_i;
+    transform_inits(context, params_i, params_r_vec, pstream);
+    params_r = Eigen::Map<Eigen::Matrix<double,-1,1>>(params_r_vec.data(),
+                 params_r_vec.size());
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context, std::vector<int>&
+                  params_i, std::vector<double>& vars, std::ostream*
+                  pstream__ = nullptr) const {
+    vars.resize(num_params_r__);
+    transform_inits_impl(context, vars, pstream__);
+  }
+  inline void
+  unconstrain_array(const std::vector<double>& params_constrained,
+                    std::vector<double>& params_unconstrained, std::ostream*
+                    pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = std::vector<double>(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+  inline void
+  unconstrain_array(const Eigen::Matrix<double,-1,1>& params_constrained,
+                    Eigen::Matrix<double,-1,1>& params_unconstrained,
+                    std::ostream* pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = Eigen::Matrix<double,-1,1>::Constant(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+};
+}
+using stan_model = single_indexing_model_namespace::single_indexing_model;
+#ifndef USING_R
+// Boilerplate
+stan::model::model_base&
+new_model(stan::io::var_context& data_context, unsigned int seed,
+          std::ostream* msg_stream) {
+  stan_model* m = new stan_model(data_context, seed, msg_stream);
+  return *m;
+}
+stan::math::profile_map& get_stan_profile_data() {
+  return single_indexing_model_namespace::profiles__;
+}
+#endif
+  $ ../../../../../../install/default/bin/stanc --use-opencl --print-cpp tp_reused.stan
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace tp_reused_model_namespace {
+using stan::model::model_base_crtp;
+using namespace stan::math;
+stan::math::profile_map profiles__;
+static constexpr std::array<const char*, 10> locations_array__ =
+  {" (found before start of program)",
+  " (in 'tp_reused.stan', line 16, column 4 to column 36)",
+  " (in 'tp_reused.stan', line 17, column 4 to column 25)",
+  " (in 'tp_reused.stan', line 21, column 4 to column 51)",
+  " (in 'tp_reused.stan', line 22, column 4 to column 37)",
+  " (in 'tp_reused.stan', line 12, column 4 to column 16)",
+  " (in 'tp_reused.stan', line 3, column 8 to column 17)",
+  " (in 'tp_reused.stan', line 2, column 31 to line 4, column 5)",
+  " (in 'tp_reused.stan', line 7, column 8 to column 25)",
+  " (in 'tp_reused.stan', line 6, column 48 to line 8, column 5)"};
+template <typename T0__,
+          stan::require_all_t<stan::is_eigen_matrix_dynamic<T0__>,
+                              stan::is_vt_not_complex<T0__>>* = nullptr>
+Eigen::Matrix<stan::promote_args_t<stan::base_type_t<T0__>>,-1,-1>
+nono_func(const T0__& x_arg__, std::ostream* pstream__);
+template <typename T0__, typename T1__,
+          stan::require_all_t<stan::is_stan_scalar<T0__>,
+                              stan::is_eigen_matrix_dynamic<T1__>,
+                              stan::is_vt_not_complex<T1__>>* = nullptr>
+Eigen::Matrix<stan::promote_args_t<T0__, stan::base_type_t<T1__>>,-1,-1>
+okay_reduction(const T0__& sum_x, const T1__& y_arg__, std::ostream*
+               pstream__);
+template <typename T0__,
+          stan::require_all_t<stan::is_eigen_matrix_dynamic<T0__>,
+                              stan::is_vt_not_complex<T0__>>*>
+Eigen::Matrix<stan::promote_args_t<stan::base_type_t<T0__>>,-1,-1>
+nono_func(const T0__& x_arg__, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<stan::base_type_t<T0__>>;
+  int current_statement__ = 0;
+  const auto& x = stan::math::to_ref(x_arg__);
+  static constexpr bool propto__ = true;
+  // suppress unused var warning
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  // suppress unused var warning
+  (void) DUMMY_VAR__;
+  try {
+    current_statement__ = 6;
+    return x;
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+  }
+}
+template <typename T0__, typename T1__,
+          stan::require_all_t<stan::is_stan_scalar<T0__>,
+                              stan::is_eigen_matrix_dynamic<T1__>,
+                              stan::is_vt_not_complex<T1__>>*>
+Eigen::Matrix<stan::promote_args_t<T0__, stan::base_type_t<T1__>>,-1,-1>
+okay_reduction(const T0__& sum_x, const T1__& y_arg__, std::ostream*
+               pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<T0__,
+                             stan::base_type_t<T1__>>;
+  int current_statement__ = 0;
+  const auto& y = stan::math::to_ref(y_arg__);
+  static constexpr bool propto__ = true;
+  // suppress unused var warning
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  // suppress unused var warning
+  (void) DUMMY_VAR__;
+  try {
+    current_statement__ = 8;
+    return stan::math::add(sum_x, y);
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+  }
+}
+class tp_reused_model final : public model_base_crtp<tp_reused_model> {
+ private:
+  double data_r;
+ public:
+  ~tp_reused_model() {}
+  tp_reused_model(stan::io::var_context& context__, unsigned int
+                  random_seed__ = 0, std::ostream* pstream__ = nullptr)
+      : model_base_crtp(0) {
+    int current_statement__ = 0;
+    using local_scalar_t__ = double;
+    boost::ecuyer1988 base_rng__ =
+      stan::services::util::create_rng(random_seed__, 0);
+    // suppress unused var warning
+    (void) base_rng__;
+    static constexpr const char* function__ =
+      "tp_reused_model_namespace::tp_reused_model";
+    // suppress unused var warning
+    (void) function__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 5;
+      context__.validate_dims("data initialization", "data_r", "double",
+        std::vector<size_t>{});
+      data_r = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 5;
+      data_r = context__.vals_r("data_r")[(1 - 1)];
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    num_params_r__ = (5 * 10) + (5 * 10);
+  }
+  inline std::string model_name() const final {
+    return "tp_reused_model";
+  }
+  inline std::vector<std::string> model_compile_info() const noexcept {
+    return std::vector<std::string>{"stanc_version = %%NAME%%3 %%VERSION%%",
+             "stancflags = --use-opencl --print-cpp"};
+  }
+  // Base log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_not_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "tp_reused_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> first_pass_soa_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      first_pass_soa_x = in__.template read<
+                           Eigen::Matrix<local_scalar_t__,-1,-1>>(5, 10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      aos_x = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5,
+                10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> tp_matrix_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 3;
+      stan::model::assign(tp_matrix_aos, first_pass_soa_x,
+        "assigning variable tp_matrix_aos");
+      current_statement__ = 4;
+      stan::model::assign(tp_matrix_aos, nono_func(aos_x, pstream__),
+        "assigning variable tp_matrix_aos");
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  // Reverse mode autodiff log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "tp_reused_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> first_pass_soa_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      first_pass_soa_x = in__.template read<
+                           Eigen::Matrix<local_scalar_t__,-1,-1>>(5, 10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      aos_x = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5,
+                10);
+      Eigen::Matrix<local_scalar_t__,-1,-1> tp_matrix_aos =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 3;
+      stan::model::assign(tp_matrix_aos, first_pass_soa_x,
+        "assigning variable tp_matrix_aos");
+      current_statement__ = 4;
+      stan::model::assign(tp_matrix_aos, nono_func(aos_x, pstream__),
+        "assigning variable tp_matrix_aos");
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  template <typename RNG, typename VecR, typename VecI, typename VecVar,
+            stan::require_vector_like_vt<std::is_floating_point,
+            VecR>* = nullptr, stan::require_vector_like_vt<std::is_integral,
+            VecI>* = nullptr, stan::require_vector_vt<std::is_floating_point,
+            VecVar>* = nullptr>
+  inline void
+  write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__,
+                   VecVar& vars__, const bool
+                   emit_transformed_parameters__ = true, const bool
+                   emit_generated_quantities__ = true, std::ostream*
+                   pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    static constexpr bool propto__ = true;
+    // suppress unused var warning
+    (void) propto__;
+    double lp__ = 0.0;
+    // suppress unused var warning
+    (void) lp__;
+    int current_statement__ = 0;
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    constexpr bool jacobian__ = false;
+    // suppress unused var warning
+    (void) jacobian__;
+    static constexpr const char* function__ =
+      "tp_reused_model_namespace::write_array";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      Eigen::Matrix<double,-1,-1> first_pass_soa_x =
+        Eigen::Matrix<double,-1,-1>::Constant(5, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 1;
+      first_pass_soa_x = in__.template read<
+                           Eigen::Matrix<local_scalar_t__,-1,-1>>(5, 10);
+      Eigen::Matrix<double,-1,-1> aos_x =
+        Eigen::Matrix<double,-1,-1>::Constant(5, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 2;
+      aos_x = in__.template read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5,
+                10);
+      Eigen::Matrix<double,-1,-1> tp_matrix_aos =
+        Eigen::Matrix<double,-1,-1>::Constant(5, 10,
+          std::numeric_limits<double>::quiet_NaN());
+      out__.write(first_pass_soa_x);
+      out__.write(aos_x);
+      if (stan::math::logical_negation(
+            (stan::math::primitive_value(emit_transformed_parameters__) ||
+            stan::math::primitive_value(emit_generated_quantities__)))) {
+        return ;
+      }
+      current_statement__ = 3;
+      stan::model::assign(tp_matrix_aos, first_pass_soa_x,
+        "assigning variable tp_matrix_aos");
+      current_statement__ = 4;
+      stan::model::assign(tp_matrix_aos, nono_func(aos_x, pstream__),
+        "assigning variable tp_matrix_aos");
+      if (emit_transformed_parameters__) {
+        out__.write(tp_matrix_aos);
+      }
+      if (stan::math::logical_negation(emit_generated_quantities__)) {
+        return ;
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, typename VecI,
+            stan::require_vector_t<VecVar>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr>
+  inline void
+  unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__,
+                         VecVar& vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      Eigen::Matrix<local_scalar_t__,-1,-1> first_pass_soa_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 1;
+      stan::model::assign(first_pass_soa_x,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5, 10),
+        "assigning variable first_pass_soa_x");
+      out__.write(first_pass_soa_x);
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      current_statement__ = 2;
+      stan::model::assign(aos_x,
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(5, 10),
+        "assigning variable aos_x");
+      out__.write(aos_x);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, stan::require_vector_t<VecVar>* = nullptr>
+  inline void
+  transform_inits_impl(const stan::io::var_context& context__, VecVar&
+                       vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 1;
+      context__.validate_dims("parameter initialization", "first_pass_soa_x",
+        "double",
+        std::vector<size_t>{static_cast<size_t>(5), static_cast<size_t>(10)});
+      current_statement__ = 2;
+      context__.validate_dims("parameter initialization", "aos_x", "double",
+        std::vector<size_t>{static_cast<size_t>(5), static_cast<size_t>(10)});
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      Eigen::Matrix<local_scalar_t__,-1,-1> first_pass_soa_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> first_pass_soa_x_flat__;
+        current_statement__ = 1;
+        first_pass_soa_x_flat__ = context__.vals_r("first_pass_soa_x");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+            stan::model::assign(first_pass_soa_x,
+              first_pass_soa_x_flat__[(pos__ - 1)],
+              "assigning variable first_pass_soa_x",
+              stan::model::index_uni(sym2__), stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(first_pass_soa_x);
+      Eigen::Matrix<local_scalar_t__,-1,-1> aos_x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(5, 10, DUMMY_VAR__);
+      {
+        std::vector<local_scalar_t__> aos_x_flat__;
+        current_statement__ = 2;
+        aos_x_flat__ = context__.vals_r("aos_x");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+            stan::model::assign(aos_x, aos_x_flat__[(pos__ - 1)],
+              "assigning variable aos_x", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(aos_x);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  inline void
+  get_param_names(std::vector<std::string>& names__, const bool
+                  emit_transformed_parameters__ = true, const bool
+                  emit_generated_quantities__ = true) const {
+    names__ = std::vector<std::string>{"first_pass_soa_x", "aos_x"};
+    if (emit_transformed_parameters__) {
+      std::vector<std::string> temp{"tp_matrix_aos"};
+      names__.reserve(names__.size() + temp.size());
+      names__.insert(names__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  get_dims(std::vector<std::vector<size_t>>& dimss__, const bool
+           emit_transformed_parameters__ = true, const bool
+           emit_generated_quantities__ = true) const {
+    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{static_cast<
+                                                                    size_t>(5),
+                                                 static_cast<size_t>(10)},
+                std::vector<size_t>{static_cast<size_t>(5),
+                  static_cast<size_t>(10)}};
+    if (emit_transformed_parameters__) {
+      std::vector<std::vector<size_t>>
+        temp{std::vector<size_t>{static_cast<size_t>(5),
+               static_cast<size_t>(10)}};
+      dimss__.reserve(dimss__.size() + temp.size());
+      dimss__.insert(dimss__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  constrained_param_names(std::vector<std::string>& param_names__, bool
+                          emit_transformed_parameters__ = true, bool
+                          emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+        param_names__.emplace_back(std::string() + "first_pass_soa_x" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+        param_names__.emplace_back(std::string() + "aos_x" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+          param_names__.emplace_back(std::string() + "tp_matrix_aos" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  unconstrained_param_names(std::vector<std::string>& param_names__, bool
+                            emit_transformed_parameters__ = true, bool
+                            emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+        param_names__.emplace_back(std::string() + "first_pass_soa_x" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+        param_names__.emplace_back(std::string() + "aos_x" + '.' +
+          std::to_string(sym2__) + '.' + std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      for (int sym1__ = 1; sym1__ <= 10; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 5; ++sym2__) {
+          param_names__.emplace_back(std::string() + "tp_matrix_aos" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline std::string get_constrained_sizedtypes() const {
+    return std::string("[{\"name\":\"first_pass_soa_x\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"aos_x\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"tp_matrix_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  inline std::string get_unconstrained_sizedtypes() const {
+    return std::string("[{\"name\":\"first_pass_soa_x\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"aos_x\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"parameters\"},{\"name\":\"tp_matrix_aos\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(5) + ",\"cols\":" + std::to_string(10) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  // Begin method overload boilerplate
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, Eigen::Matrix<double,-1,1>& params_r,
+              Eigen::Matrix<double,-1,1>& vars, const bool
+              emit_transformed_parameters = true, const bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = ((5 * 10) + (5 * 10));
+    const size_t num_transformed = emit_transformed_parameters * ((5 * 10));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    std::vector<int> params_i;
+    vars = Eigen::Matrix<double,-1,1>::Constant(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, std::vector<double>& params_r, std::vector<int>&
+              params_i, std::vector<double>& vars, bool
+              emit_transformed_parameters = true, bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = ((5 * 10) + (5 * 10));
+    const size_t num_transformed = emit_transformed_parameters * ((5 * 10));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    vars = std::vector<double>(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(Eigen::Matrix<T_,-1,1>& params_r, std::ostream* pstream = nullptr) const {
+    Eigen::Matrix<int,-1,1> params_i;
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(std::vector<T_>& params_r, std::vector<int>& params_i,
+           std::ostream* pstream = nullptr) const {
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context,
+                  Eigen::Matrix<double,-1,1>& params_r, std::ostream*
+                  pstream = nullptr) const final {
+    std::vector<double> params_r_vec(params_r.size());
+    std::vector<int> params_i;
+    transform_inits(context, params_i, params_r_vec, pstream);
+    params_r = Eigen::Map<Eigen::Matrix<double,-1,1>>(params_r_vec.data(),
+                 params_r_vec.size());
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context, std::vector<int>&
+                  params_i, std::vector<double>& vars, std::ostream*
+                  pstream__ = nullptr) const {
+    vars.resize(num_params_r__);
+    transform_inits_impl(context, vars, pstream__);
+  }
+  inline void
+  unconstrain_array(const std::vector<double>& params_constrained,
+                    std::vector<double>& params_unconstrained, std::ostream*
+                    pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = std::vector<double>(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+  inline void
+  unconstrain_array(const Eigen::Matrix<double,-1,1>& params_constrained,
+                    Eigen::Matrix<double,-1,1>& params_unconstrained,
+                    std::ostream* pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = Eigen::Matrix<double,-1,1>::Constant(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+};
+}
+using stan_model = tp_reused_model_namespace::tp_reused_model;
+#ifndef USING_R
+// Boilerplate
+stan::model::model_base&
+new_model(stan::io::var_context& data_context, unsigned int seed,
+          std::ostream* msg_stream) {
+  stan_model* m = new stan_model(data_context, seed, msg_stream);
+  return *m;
+}
+stan::math::profile_map& get_stan_profile_data() {
+  return tp_reused_model_namespace::profiles__;
+}
+#endif
+OpenCL (Line 22) warning: Right hand side of assignment is all AoS: aos_x, tp_matrix_aos
+OpenCL (Line 22) warning: Function on right hand side of assignment is not supported by SoA: aos_x, tp_matrix_aos
+  $ ../../../../../../install/default/bin/stanc --use-opencl --print-cpp tuple_test.stan
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace tuple_test_model_namespace {
+using stan::model::model_base_crtp;
+using namespace stan::math;
+stan::math::profile_map profiles__;
+static constexpr std::array<const char*, 10> locations_array__ =
+  {" (found before start of program)",
+  " (in 'tuple_test.stan', line 3, column 4 to column 61)",
+  " (in 'tuple_test.stan', line 6, column 4 to column 28)",
+  " (in 'tuple_test.stan', line 3, column 16 to column 17)",
+  " (in 'tuple_test.stan', line 3, column 26 to column 27)",
+  " (in 'tuple_test.stan', line 3, column 28 to column 29)",
+  " (in 'tuple_test.stan', line 3, column 39 to column 40)",
+  " (in 'tuple_test.stan', line 3, column 52 to column 53)",
+  " (in 'tuple_test.stan', line 6, column 11 to column 12)",
+  " (in 'tuple_test.stan', line 6, column 13 to column 14)"};
+class tuple_test_model final : public model_base_crtp<tuple_test_model> {
+ private:
+  
+ public:
+  ~tuple_test_model() {}
+  tuple_test_model(stan::io::var_context& context__, unsigned int
+                   random_seed__ = 0, std::ostream* pstream__ = nullptr)
+      : model_base_crtp(0) {
+    int current_statement__ = 0;
+    using local_scalar_t__ = double;
+    boost::ecuyer1988 base_rng__ =
+      stan::services::util::create_rng(random_seed__, 0);
+    // suppress unused var warning
+    (void) base_rng__;
+    static constexpr const char* function__ =
+      "tuple_test_model_namespace::tuple_test_model";
+    // suppress unused var warning
+    (void) function__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 3;
+      stan::math::validate_non_negative_index("xx.1", "1", 1);
+      current_statement__ = 4;
+      stan::math::validate_non_negative_index("xx.1", "1", 1);
+      current_statement__ = 5;
+      stan::math::validate_non_negative_index("xx.1", "1", 1);
+      current_statement__ = 6;
+      stan::math::validate_non_negative_index("xx.2", "1", 1);
+      current_statement__ = 7;
+      stan::math::validate_non_negative_index("xx.3", "1", 1);
+      current_statement__ = 8;
+      stan::math::validate_non_negative_index("x", "1", 1);
+      current_statement__ = 9;
+      stan::math::validate_non_negative_index("x", "1", 1);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    num_params_r__ = (((1 * (1 * 1)) + (1 * 2)) + (1 * 3));
+  }
+  inline std::string model_name() const final {
+    return "tuple_test_model";
+  }
+  inline std::vector<std::string> model_compile_info() const noexcept {
+    return std::vector<std::string>{"stanc_version = %%NAME%%3 %%VERSION%%",
+             "stancflags = --use-opencl --print-cpp"};
+  }
+  // Base log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_not_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "tuple_test_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      std::tuple<std::vector<Eigen::Matrix<local_scalar_t__,-1,-1>>,
+        Eigen::Matrix<local_scalar_t__,-1,-1>,
+        Eigen::Matrix<local_scalar_t__,-1,-1>> xx =
+        std::tuple<std::vector<Eigen::Matrix<local_scalar_t__,-1,-1>>,
+          Eigen::Matrix<local_scalar_t__,-1,-1>,
+          Eigen::Matrix<local_scalar_t__,-1,-1>>{std::vector<
+                                                   Eigen::Matrix<local_scalar_t__,-1,-1>>(1,
+                                                   Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1,
+                                                     1, DUMMY_VAR__)),
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1, 2, DUMMY_VAR__),
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1, 3, DUMMY_VAR__)};
+      current_statement__ = 1;
+      std::get<0>(xx) = in__.template read<
+                          std::vector<Eigen::Matrix<local_scalar_t__,-1,-1>>>(1,
+                          1, 1);
+      current_statement__ = 1;
+      std::get<1>(xx) = in__.template read<
+                          Eigen::Matrix<local_scalar_t__,-1,-1>>(1, 2);
+      current_statement__ = 1;
+      std::get<2>(xx) = in__.template read<
+                          Eigen::Matrix<local_scalar_t__,-1,-1>>(1, 3);
+      Eigen::Matrix<local_scalar_t__,-1,-1> x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1, 1, DUMMY_VAR__);
+      current_statement__ = 2;
+      stan::model::assign(x,
+        stan::model::rvalue(std::get<0>(xx), "xx.1",
+          stan::model::index_uni(1)), "assigning variable x");
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  // Reverse mode autodiff log prob
+  template <bool propto__, bool jacobian__, typename VecR, typename VecI,
+            stan::require_vector_like_t<VecR>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr,
+            stan::require_st_var<VecR>* = nullptr>
+  inline stan::scalar_type_t<VecR>
+  log_prob_impl(VecR& params_r__, VecI& params_i__, std::ostream*
+                pstream__ = nullptr) const {
+    using T__ = stan::scalar_type_t<VecR>;
+    using local_scalar_t__ = T__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    static constexpr const char* function__ =
+      "tuple_test_model_namespace::log_prob";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      std::tuple<std::vector<Eigen::Matrix<local_scalar_t__,-1,-1>>,
+        Eigen::Matrix<local_scalar_t__,-1,-1>,
+        Eigen::Matrix<local_scalar_t__,-1,-1>> xx =
+        std::tuple<std::vector<Eigen::Matrix<local_scalar_t__,-1,-1>>,
+          Eigen::Matrix<local_scalar_t__,-1,-1>,
+          Eigen::Matrix<local_scalar_t__,-1,-1>>{std::vector<
+                                                   Eigen::Matrix<local_scalar_t__,-1,-1>>(1,
+                                                   Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1,
+                                                     1, DUMMY_VAR__)),
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1, 2, DUMMY_VAR__),
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1, 3, DUMMY_VAR__)};
+      current_statement__ = 1;
+      std::get<0>(xx) = in__.template read<
+                          std::vector<Eigen::Matrix<local_scalar_t__,-1,-1>>>(1,
+                          1, 1);
+      current_statement__ = 1;
+      std::get<1>(xx) = in__.template read<
+                          Eigen::Matrix<local_scalar_t__,-1,-1>>(1, 2);
+      current_statement__ = 1;
+      std::get<2>(xx) = in__.template read<
+                          Eigen::Matrix<local_scalar_t__,-1,-1>>(1, 3);
+      Eigen::Matrix<local_scalar_t__,-1,-1> x =
+        Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1, 1, DUMMY_VAR__);
+      current_statement__ = 2;
+      stan::model::assign(x,
+        stan::model::rvalue(std::get<0>(xx), "xx.1",
+          stan::model::index_uni(1)), "assigning variable x");
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+  }
+  template <typename RNG, typename VecR, typename VecI, typename VecVar,
+            stan::require_vector_like_vt<std::is_floating_point,
+            VecR>* = nullptr, stan::require_vector_like_vt<std::is_integral,
+            VecI>* = nullptr, stan::require_vector_vt<std::is_floating_point,
+            VecVar>* = nullptr>
+  inline void
+  write_array_impl(RNG& base_rng__, VecR& params_r__, VecI& params_i__,
+                   VecVar& vars__, const bool
+                   emit_transformed_parameters__ = true, const bool
+                   emit_generated_quantities__ = true, std::ostream*
+                   pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    static constexpr bool propto__ = true;
+    // suppress unused var warning
+    (void) propto__;
+    double lp__ = 0.0;
+    // suppress unused var warning
+    (void) lp__;
+    int current_statement__ = 0;
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    constexpr bool jacobian__ = false;
+    // suppress unused var warning
+    (void) jacobian__;
+    static constexpr const char* function__ =
+      "tuple_test_model_namespace::write_array";
+    // suppress unused var warning
+    (void) function__;
+    try {
+      std::tuple<std::vector<Eigen::Matrix<double,-1,-1>>,
+        Eigen::Matrix<double,-1,-1>, Eigen::Matrix<double,-1,-1>> xx =
+        std::tuple<std::vector<Eigen::Matrix<double,-1,-1>>,
+          Eigen::Matrix<double,-1,-1>, Eigen::Matrix<double,-1,-1>>{std::vector<
+                                                                    Eigen::Matrix<double,-1,-1>>(1,
+                                                                    Eigen::Matrix<double,-1,-1>::Constant(1,
+                                                                    1,
+                                                                    std::numeric_limits<double>::quiet_NaN(
+                                                                    ))),
+          Eigen::Matrix<double,-1,-1>::Constant(1, 2,
+            std::numeric_limits<double>::quiet_NaN()),
+          Eigen::Matrix<double,-1,-1>::Constant(1, 3,
+            std::numeric_limits<double>::quiet_NaN())};
+      current_statement__ = 1;
+      std::get<0>(xx) = in__.template read<
+                          std::vector<Eigen::Matrix<local_scalar_t__,-1,-1>>>(1,
+                          1, 1);
+      current_statement__ = 1;
+      std::get<1>(xx) = in__.template read<
+                          Eigen::Matrix<local_scalar_t__,-1,-1>>(1, 2);
+      current_statement__ = 1;
+      std::get<2>(xx) = in__.template read<
+                          Eigen::Matrix<local_scalar_t__,-1,-1>>(1, 3);
+      Eigen::Matrix<double,-1,-1> x =
+        Eigen::Matrix<double,-1,-1>::Constant(1, 1,
+          std::numeric_limits<double>::quiet_NaN());
+      current_statement__ = 1;
+      for (int sym1__ = 1; sym1__ <= 1; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 1; ++sym2__) {
+          for (int sym3__ = 1; sym3__ <= 1; ++sym3__) {
+            out__.write(stan::model::rvalue(std::get<0>(xx), "xx.1",
+                          stan::model::index_uni(sym3__),
+                          stan::model::index_uni(sym2__),
+                          stan::model::index_uni(sym1__)));
+          }
+        }
+      }
+      out__.write(std::get<1>(xx));
+      out__.write(std::get<2>(xx));
+      if (stan::math::logical_negation(
+            (stan::math::primitive_value(emit_transformed_parameters__) ||
+            stan::math::primitive_value(emit_generated_quantities__)))) {
+        return ;
+      }
+      current_statement__ = 2;
+      stan::model::assign(x,
+        stan::model::rvalue(std::get<0>(xx), "xx.1",
+          stan::model::index_uni(1)), "assigning variable x");
+      if (emit_transformed_parameters__) {
+        out__.write(x);
+      }
+      if (stan::math::logical_negation(emit_generated_quantities__)) {
+        return ;
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, typename VecI,
+            stan::require_vector_t<VecVar>* = nullptr,
+            stan::require_vector_like_vt<std::is_integral, VecI>* = nullptr>
+  inline void
+  unconstrain_array_impl(const VecVar& params_r__, const VecI& params_i__,
+                         VecVar& vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::deserializer<local_scalar_t__> in__(params_r__, params_i__);
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      std::tuple<std::vector<Eigen::Matrix<local_scalar_t__,-1,-1>>,
+        Eigen::Matrix<local_scalar_t__,-1,-1>,
+        Eigen::Matrix<local_scalar_t__,-1,-1>> xx =
+        std::tuple<std::vector<Eigen::Matrix<local_scalar_t__,-1,-1>>,
+          Eigen::Matrix<local_scalar_t__,-1,-1>,
+          Eigen::Matrix<local_scalar_t__,-1,-1>>{std::vector<
+                                                   Eigen::Matrix<local_scalar_t__,-1,-1>>(1,
+                                                   Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1,
+                                                     1, DUMMY_VAR__)),
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1, 2, DUMMY_VAR__),
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1, 3, DUMMY_VAR__)};
+      current_statement__ = 1;
+      for (int sym1__ = 1; sym1__ <= 1; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 1; ++sym2__) {
+          for (int sym3__ = 1; sym3__ <= 1; ++sym3__) {
+            current_statement__ = 1;
+            stan::model::assign(std::get<0>(xx),
+              in__.read<local_scalar_t__>(), "assigning variable xx.1",
+              stan::model::index_uni(sym3__), stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+          }
+        }
+      }
+      current_statement__ = 1;
+      stan::model::assign(std::get<1>(xx),
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(1, 2),
+        "assigning variable xx.2");
+      current_statement__ = 1;
+      stan::model::assign(std::get<2>(xx),
+        in__.read<Eigen::Matrix<local_scalar_t__,-1,-1>>(1, 3),
+        "assigning variable xx.3");
+      out__.write(std::get<0>(xx));
+      out__.write(std::get<1>(xx));
+      out__.write(std::get<2>(xx));
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  template <typename VecVar, stan::require_vector_t<VecVar>* = nullptr>
+  inline void
+  transform_inits_impl(const stan::io::var_context& context__, VecVar&
+                       vars__, std::ostream* pstream__ = nullptr) const {
+    using local_scalar_t__ = double;
+    stan::io::serializer<local_scalar_t__> out__(vars__);
+    int current_statement__ = 0;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    // suppress unused var warning
+    (void) DUMMY_VAR__;
+    try {
+      current_statement__ = 1;
+      context__.validate_dims("parameter initialization", "xx.1", "double",
+        std::vector<size_t>{static_cast<size_t>(1), static_cast<size_t>(1),
+          static_cast<size_t>(1)});
+      context__.validate_dims("parameter initialization", "xx.2", "double",
+        std::vector<size_t>{static_cast<size_t>(1), static_cast<size_t>(2)});
+      context__.validate_dims("parameter initialization", "xx.3", "double",
+        std::vector<size_t>{static_cast<size_t>(1), static_cast<size_t>(3)});
+      int pos__ = std::numeric_limits<int>::min();
+      pos__ = 1;
+      std::tuple<std::vector<Eigen::Matrix<local_scalar_t__,-1,-1>>,
+        Eigen::Matrix<local_scalar_t__,-1,-1>,
+        Eigen::Matrix<local_scalar_t__,-1,-1>> xx =
+        std::tuple<std::vector<Eigen::Matrix<local_scalar_t__,-1,-1>>,
+          Eigen::Matrix<local_scalar_t__,-1,-1>,
+          Eigen::Matrix<local_scalar_t__,-1,-1>>{std::vector<
+                                                   Eigen::Matrix<local_scalar_t__,-1,-1>>(1,
+                                                   Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1,
+                                                     1, DUMMY_VAR__)),
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1, 2, DUMMY_VAR__),
+          Eigen::Matrix<local_scalar_t__,-1,-1>::Constant(1, 3, DUMMY_VAR__)};
+      {
+        std::vector<local_scalar_t__> xx_dot_1_flat__;
+        current_statement__ = 1;
+        xx_dot_1_flat__ = context__.vals_r("xx.1");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 1; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 1; ++sym2__) {
+            for (int sym3__ = 1; sym3__ <= 1; ++sym3__) {
+              stan::model::assign(std::get<0>(xx), xx_dot_1_flat__[(pos__ -
+                1)], "assigning variable xx.1",
+                stan::model::index_uni(sym3__),
+                stan::model::index_uni(sym2__),
+                stan::model::index_uni(sym1__));
+              pos__ = (pos__ + 1);
+            }
+          }
+        }
+      }
+      {
+        std::vector<local_scalar_t__> xx_dot_2_flat__;
+        xx_dot_2_flat__ = context__.vals_r("xx.2");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 2; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 1; ++sym2__) {
+            stan::model::assign(std::get<1>(xx), xx_dot_2_flat__[(pos__ -
+              1)], "assigning variable xx.2", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      {
+        std::vector<local_scalar_t__> xx_dot_3_flat__;
+        xx_dot_3_flat__ = context__.vals_r("xx.3");
+        pos__ = 1;
+        for (int sym1__ = 1; sym1__ <= 3; ++sym1__) {
+          for (int sym2__ = 1; sym2__ <= 1; ++sym2__) {
+            stan::model::assign(std::get<2>(xx), xx_dot_3_flat__[(pos__ -
+              1)], "assigning variable xx.3", stan::model::index_uni(sym2__),
+              stan::model::index_uni(sym1__));
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      out__.write(std::get<0>(xx));
+      out__.write(std::get<1>(xx));
+      out__.write(std::get<2>(xx));
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+    }
+  }
+  inline void
+  get_param_names(std::vector<std::string>& names__, const bool
+                  emit_transformed_parameters__ = true, const bool
+                  emit_generated_quantities__ = true) const {
+    names__ = std::vector<std::string>{"xx.1", "xx.2", "xx.3"};
+    if (emit_transformed_parameters__) {
+      std::vector<std::string> temp{"x"};
+      names__.reserve(names__.size() + temp.size());
+      names__.insert(names__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  get_dims(std::vector<std::vector<size_t>>& dimss__, const bool
+           emit_transformed_parameters__ = true, const bool
+           emit_generated_quantities__ = true) const {
+    dimss__ = std::vector<std::vector<size_t>>{std::vector<size_t>{static_cast<
+                                                                    size_t>(1),
+                                                 static_cast<size_t>(1),
+                                                 static_cast<size_t>(1)},
+                std::vector<size_t>{static_cast<size_t>(1),
+                  static_cast<size_t>(2)},
+                std::vector<size_t>{static_cast<size_t>(1),
+                  static_cast<size_t>(3)}};
+    if (emit_transformed_parameters__) {
+      std::vector<std::vector<size_t>>
+        temp{std::vector<size_t>{static_cast<size_t>(1),
+               static_cast<size_t>(1)}};
+      dimss__.reserve(dimss__.size() + temp.size());
+      dimss__.insert(dimss__.end(), temp.begin(), temp.end());
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  constrained_param_names(std::vector<std::string>& param_names__, bool
+                          emit_transformed_parameters__ = true, bool
+                          emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 1; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 1; ++sym2__) {
+        for (int sym3__ = 1; sym3__ <= 1; ++sym3__) {
+          param_names__.emplace_back(std::string() + "xx" + ':' +
+            std::to_string(1) + '.' + std::to_string(sym3__) + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 2; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 1; ++sym2__) {
+        param_names__.emplace_back(std::string() + "xx" + ':' +
+          std::to_string(2) + '.' + std::to_string(sym2__) + '.' +
+          std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 3; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 1; ++sym2__) {
+        param_names__.emplace_back(std::string() + "xx" + ':' +
+          std::to_string(3) + '.' + std::to_string(sym2__) + '.' +
+          std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      for (int sym1__ = 1; sym1__ <= 1; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 1; ++sym2__) {
+          param_names__.emplace_back(std::string() + "x" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline void
+  unconstrained_param_names(std::vector<std::string>& param_names__, bool
+                            emit_transformed_parameters__ = true, bool
+                            emit_generated_quantities__ = true) const final {
+    for (int sym1__ = 1; sym1__ <= 1; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 1; ++sym2__) {
+        for (int sym3__ = 1; sym3__ <= 1; ++sym3__) {
+          param_names__.emplace_back(std::string() + "xx" + ':' +
+            std::to_string(1) + '.' + std::to_string(sym3__) + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 2; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 1; ++sym2__) {
+        param_names__.emplace_back(std::string() + "xx" + ':' +
+          std::to_string(2) + '.' + std::to_string(sym2__) + '.' +
+          std::to_string(sym1__));
+      }
+    }
+    for (int sym1__ = 1; sym1__ <= 3; ++sym1__) {
+      for (int sym2__ = 1; sym2__ <= 1; ++sym2__) {
+        param_names__.emplace_back(std::string() + "xx" + ':' +
+          std::to_string(3) + '.' + std::to_string(sym2__) + '.' +
+          std::to_string(sym1__));
+      }
+    }
+    if (emit_transformed_parameters__) {
+      for (int sym1__ = 1; sym1__ <= 1; ++sym1__) {
+        for (int sym2__ = 1; sym2__ <= 1; ++sym2__) {
+          param_names__.emplace_back(std::string() + "x" + '.' +
+            std::to_string(sym2__) + '.' + std::to_string(sym1__));
+        }
+      }
+    }
+    if (emit_generated_quantities__) {}
+  }
+  inline std::string get_constrained_sizedtypes() const {
+    return std::string("[{\"name\":\"xx\",\"type\":{\"name\":\"tuple\",\"num_elements\":\"3\",\"element_types\":[{\"name\":\"array\",\"length\":" + std::to_string(1) + ",\"element_type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(1) + ",\"cols\":" + std::to_string(1) + "}},{\"name\":\"matrix\",\"rows\":" + std::to_string(1) + ",\"cols\":" + std::to_string(2) + "},{\"name\":\"matrix\",\"rows\":" + std::to_string(1) + ",\"cols\":" + std::to_string(3) + "}]},\"block\":\"parameters\"},{\"name\":\"x\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(1) + ",\"cols\":" + std::to_string(1) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  inline std::string get_unconstrained_sizedtypes() const {
+    return std::string("[{\"name\":\"xx\",\"type\":{\"name\":\"tuple\",\"num_elements\":\"3\",\"element_types\":[{\"name\":\"array\",\"length\":" + std::to_string(1) + ",\"element_type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(1) + ",\"cols\":" + std::to_string(1) + "}},{\"name\":\"matrix\",\"rows\":" + std::to_string(1) + ",\"cols\":" + std::to_string(2) + "},{\"name\":\"matrix\",\"rows\":" + std::to_string(1) + ",\"cols\":" + std::to_string(3) + "}]},\"block\":\"parameters\"},{\"name\":\"x\",\"type\":{\"name\":\"matrix\",\"rows\":" + std::to_string(1) + ",\"cols\":" + std::to_string(1) + "},\"block\":\"transformed_parameters\"}]");
+  }
+  // Begin method overload boilerplate
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, Eigen::Matrix<double,-1,1>& params_r,
+              Eigen::Matrix<double,-1,1>& vars, const bool
+              emit_transformed_parameters = true, const bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (((1 * (1 * 1)) + (1 * 2)) + (1 * 3));
+    const size_t num_transformed = emit_transformed_parameters * ((1 * 1));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    std::vector<int> params_i;
+    vars = Eigen::Matrix<double,-1,1>::Constant(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <typename RNG> inline void
+  write_array(RNG& base_rng, std::vector<double>& params_r, std::vector<int>&
+              params_i, std::vector<double>& vars, bool
+              emit_transformed_parameters = true, bool
+              emit_generated_quantities = true, std::ostream*
+              pstream = nullptr) const {
+    const size_t num_params__ = (((1 * (1 * 1)) + (1 * 2)) + (1 * 3));
+    const size_t num_transformed = emit_transformed_parameters * ((1 * 1));
+    const size_t num_gen_quantities = emit_generated_quantities * (0);
+    const size_t num_to_write = num_params__ + num_transformed +
+      num_gen_quantities;
+    vars = std::vector<double>(num_to_write,
+             std::numeric_limits<double>::quiet_NaN());
+    write_array_impl(base_rng, params_r, params_i, vars,
+      emit_transformed_parameters, emit_generated_quantities, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(Eigen::Matrix<T_,-1,1>& params_r, std::ostream* pstream = nullptr) const {
+    Eigen::Matrix<int,-1,1> params_i;
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  template <bool propto__, bool jacobian__, typename T_> inline T_
+  log_prob(std::vector<T_>& params_r, std::vector<int>& params_i,
+           std::ostream* pstream = nullptr) const {
+    return log_prob_impl<propto__, jacobian__>(params_r, params_i, pstream);
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context,
+                  Eigen::Matrix<double,-1,1>& params_r, std::ostream*
+                  pstream = nullptr) const final {
+    std::vector<double> params_r_vec(params_r.size());
+    std::vector<int> params_i;
+    transform_inits(context, params_i, params_r_vec, pstream);
+    params_r = Eigen::Map<Eigen::Matrix<double,-1,1>>(params_r_vec.data(),
+                 params_r_vec.size());
+  }
+  inline void
+  transform_inits(const stan::io::var_context& context, std::vector<int>&
+                  params_i, std::vector<double>& vars, std::ostream*
+                  pstream__ = nullptr) const {
+    vars.resize(num_params_r__);
+    transform_inits_impl(context, vars, pstream__);
+  }
+  inline void
+  unconstrain_array(const std::vector<double>& params_constrained,
+                    std::vector<double>& params_unconstrained, std::ostream*
+                    pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = std::vector<double>(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+  inline void
+  unconstrain_array(const Eigen::Matrix<double,-1,1>& params_constrained,
+                    Eigen::Matrix<double,-1,1>& params_unconstrained,
+                    std::ostream* pstream = nullptr) const {
+    const std::vector<int> params_i;
+    params_unconstrained = Eigen::Matrix<double,-1,1>::Constant(num_params_r__,
+                             std::numeric_limits<double>::quiet_NaN());
+    unconstrain_array_impl(params_constrained, params_i,
+      params_unconstrained, pstream);
+  }
+};
+}
+using stan_model = tuple_test_model_namespace::tuple_test_model;
+#ifndef USING_R
+// Boilerplate
+stan::model::model_base&
+new_model(stan::io::var_context& data_context, unsigned int seed,
+          std::ostream* msg_stream) {
+  stan_model* m = new stan_model(data_context, seed, msg_stream);
+  return *m;
+}
+stan::math::profile_map& get_stan_profile_data() {
+  return tuple_test_model_namespace::profiles__;
+}
+#endif
+OpenCL (Line 6) warning: Right hand side of assignment is all AoS: x, xx
+OpenCL (Line 6) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: x, xx
diff --git a/test/integration/good/compiler-optimizations/mem_patterns/dune b/test/integration/good/compiler-optimizations/mem_patterns/dune
index 4cde474b9..32e74f823 100644
--- a/test/integration/good/compiler-optimizations/mem_patterns/dune
+++ b/test/integration/good/compiler-optimizations/mem_patterns/dune
@@ -14,6 +14,25 @@
  (action
   (diff cpp.expected cpp.output)))
 
+(rule
+ (targets cppOpenCL.output)
+ (deps
+  (package stanc)
+  (:stanfiles
+   (glob_files *.stan)))
+ (action
+  (with-stdout-to
+   %{targets}
+   (run
+    %{bin:run_bin_on_args}
+    "%{bin:stanc} --use-opencl --print-cpp"
+    %{stanfiles}))))
+
+(rule
+ (alias runtest)
+ (action
+  (diff cppOpenCL.expected cppOpenCL.output)))
+
 (rule
  (targets transformed_mir.output)
  (deps
diff --git a/test/integration/good/compiler-optimizations/mem_patterns/transformed_mir.expected b/test/integration/good/compiler-optimizations/mem_patterns/transformed_mir.expected
index c675b30d0..3a2ea1bfd 100644
--- a/test/integration/good/compiler-optimizations/mem_patterns/transformed_mir.expected
+++ b/test/integration/good/compiler-optimizations/mem_patterns/transformed_mir.expected
@@ -1,4 +1,6 @@
   $ ../../../../../../install/default/bin/stanc -fsoa --debug-optimized-mir --debug-mem-patterns ad_scalar_data_matrix.stan
+real alpha: SoA
+real sigma: SoA
 vector[N] beta: SoA
 vector[N] soa_simple: SoA
 vector[N] aos_deep: AoS
@@ -17,7 +19,7 @@ matrix[2, 2] aos_mat_from_vecs: AoS
       ((filename ad_scalar_data_matrix.stan) (line_num 2) (col_num 2) (included_from ())))
      (end_loc
       ((filename ad_scalar_data_matrix.stan) (line_num 2) (col_num 8) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (X_data
     ((begin_loc
       ((filename ad_scalar_data_matrix.stan) (line_num 3) (col_num 2) (included_from ())))
@@ -37,7 +39,7 @@ matrix[2, 2] aos_mat_from_vecs: AoS
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -45,7 +47,8 @@ matrix[2, 2] aos_mat_from_vecs: AoS
       ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable N) ()) UInt
@@ -238,7 +241,7 @@ matrix[2, 2] aos_mat_from_vecs: AoS
     (meta <opaque>))))
  (log_prob
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -251,7 +254,7 @@ matrix[2, 2] aos_mat_from_vecs: AoS
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -817,7 +820,7 @@ matrix[2, 2] aos_mat_from_vecs: AoS
     (meta <opaque>))))
  (reverse_mode_log_prob
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -830,7 +833,7 @@ matrix[2, 2] aos_mat_from_vecs: AoS
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -1396,7 +1399,7 @@ matrix[2, 2] aos_mat_from_vecs: AoS
     (meta <opaque>))))
  (generate_quantities
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -1409,7 +1412,7 @@ matrix[2, 2] aos_mat_from_vecs: AoS
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id sigma) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id sigma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -1491,7 +1494,7 @@ matrix[2, 2] aos_mat_from_vecs: AoS
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -1499,7 +1502,7 @@ matrix[2, 2] aos_mat_from_vecs: AoS
       ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -1525,7 +1528,7 @@ matrix[2, 2] aos_mat_from_vecs: AoS
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -1626,7 +1629,7 @@ matrix[2, 2] aos_mat_from_vecs: AoS
     (meta <opaque>))))
  (unconstrain_array
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -1643,7 +1646,7 @@ matrix[2, 2] aos_mat_from_vecs: AoS
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -1690,16 +1693,16 @@ matrix[2, 2] aos_mat_from_vecs: AoS
      (end_loc
       ((filename ad_scalar_data_matrix.stan) (line_num 7) (col_num 13)
        (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
-     (out_trans Identity)))
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters) (out_trans Identity)))
    (sigma
     ((begin_loc
       ((filename ad_scalar_data_matrix.stan) (line_num 8) (col_num 2) (included_from ())))
      (end_loc
       ((filename ad_scalar_data_matrix.stan) (line_num 8) (col_num 13)
        (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
-     (out_trans Identity)))
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters) (out_trans Identity)))
    (beta
     ((begin_loc
       ((filename ad_scalar_data_matrix.stan) (line_num 9) (col_num 2) (included_from ())))
@@ -1714,6 +1717,10 @@ matrix[2, 2] aos_mat_from_vecs: AoS
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block Parameters) (out_trans Identity)))))
  (prog_name ad_scalar_data_matrix_model) (prog_path ad_scalar_data_matrix.stan))
+SoA (Line 13) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: aos_deep
+SoA (Line 17) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: aos_from_data
+SoA (Line 21) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: aos_mat_from_vecs
+SoA (Line 1) warning: Right hand side contains only AoS expressions: aos_mat_rep
   $ ../../../../../../install/default/bin/stanc -fsoa --debug-optimized-mir --debug-mem-patterns complex-fails.stan
 matrix[10, 10] A_p: AoS
 ((functions_block ()) (input_vars ()) (prepare_data ())
@@ -1897,7 +1904,7 @@ matrix[10, 10] A_p: AoS
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -2059,8 +2066,13 @@ vector[N] high_low_est: SoA
 vector[K] b: SoA
 vector[Nr] h: SoA
 vector[2] ar: SoA
+real ma: SoA
+real phi_beta: SoA
+real sigma2: SoA
+real Intercept: SoA
 vector[N] mean_price: SoA
 vector[N] sigma_price: SoA
+real theta: SoA
 vector[N] upper_test: SoA
 vector[N] lower_upper_test: SoA
 row_vector[N] row_vec_lower_upper_test: SoA
@@ -2072,6 +2084,8 @@ matrix[N, N] corr_matrix_test: SoA
 matrix[N, N] cov_matrix_test: SoA
 matrix[K, K] chol_fac_cov_test: SoA
 matrix[K, K] chol_fac_corr_test: SoA
+real phi: SoA
+real sigma: SoA
 vector[N] prices: SoA
 vector[Nr] prices_diff: SoA
 vector[Nr] mu: SoA
@@ -2085,12 +2099,12 @@ vector[Nr] h_sigma: SoA
     ((begin_loc
       ((filename constraints.stan) (line_num 3) (col_num 2) (included_from ())))
      (end_loc ((filename constraints.stan) (line_num 3) (col_num 17) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (K
     ((begin_loc
       ((filename constraints.stan) (line_num 4) (col_num 2) (included_from ())))
      (end_loc ((filename constraints.stan) (line_num 4) (col_num 17) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (diff_low_mid
     ((begin_loc
       ((filename constraints.stan) (line_num 5) (col_num 2) (included_from ())))
@@ -2120,40 +2134,40 @@ vector[Nr] h_sigma: SoA
     ((begin_loc
       ((filename constraints.stan) (line_num 9) (col_num 2) (included_from ())))
      (end_loc ((filename constraints.stan) (line_num 9) (col_num 28) (included_from ()))))
-    SReal)
+    (SReal AoS))
    (phi_prior_b
     ((begin_loc
       ((filename constraints.stan) (line_num 10) (col_num 2) (included_from ())))
      (end_loc
       ((filename constraints.stan) (line_num 10) (col_num 28) (included_from ()))))
-    SReal)
+    (SReal AoS))
    (mu_prior_mu
     ((begin_loc
       ((filename constraints.stan) (line_num 11) (col_num 2) (included_from ())))
      (end_loc
       ((filename constraints.stan) (line_num 11) (col_num 19) (included_from ()))))
-    SReal)
+    (SReal AoS))
    (mu_prior_sigma
     ((begin_loc
       ((filename constraints.stan) (line_num 12) (col_num 2) (included_from ())))
      (end_loc
       ((filename constraints.stan) (line_num 12) (col_num 31) (included_from ()))))
-    SReal)
+    (SReal AoS))
    (sigma_prior_shape
     ((begin_loc
       ((filename constraints.stan) (line_num 13) (col_num 2) (included_from ())))
      (end_loc
       ((filename constraints.stan) (line_num 13) (col_num 34) (included_from ()))))
-    SReal)
+    (SReal AoS))
    (sigma_prior_rate
     ((begin_loc
       ((filename constraints.stan) (line_num 14) (col_num 2) (included_from ())))
      (end_loc
       ((filename constraints.stan) (line_num 14) (col_num 33) (included_from ()))))
-    SReal)))
+    (SReal AoS))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -2161,7 +2175,8 @@ vector[Nr] h_sigma: SoA
       ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable N) ()) UInt
@@ -2189,7 +2204,8 @@ vector[Nr] h_sigma: SoA
       (((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id K) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id K) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable K) ()) UInt
@@ -2530,7 +2546,7 @@ vector[Nr] h_sigma: SoA
         (meta <opaque>)))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id phi_prior_a) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id phi_prior_a) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -2561,7 +2577,7 @@ vector[Nr] h_sigma: SoA
       (((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id phi_prior_b) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id phi_prior_b) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -2592,7 +2608,7 @@ vector[Nr] h_sigma: SoA
       (((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id mu_prior_mu) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id mu_prior_mu) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -2610,8 +2626,8 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UReal) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id mu_prior_sigma) (decl_type (Sized SReal))
-      (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id mu_prior_sigma)
+      (decl_type (Sized (SReal AoS))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable mu_prior_sigma) ()) UReal
@@ -2641,8 +2657,8 @@ vector[Nr] h_sigma: SoA
       (((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id sigma_prior_shape) (decl_type (Sized SReal))
-      (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id sigma_prior_shape)
+      (decl_type (Sized (SReal AoS))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable sigma_prior_shape) ()) UReal
@@ -2672,8 +2688,8 @@ vector[Nr] h_sigma: SoA
       (((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id sigma_prior_rate) (decl_type (Sized SReal))
-      (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id sigma_prior_rate)
+      (decl_type (Sized (SReal AoS))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable sigma_prior_rate) ()) UReal
@@ -2703,7 +2719,7 @@ vector[Nr] h_sigma: SoA
       (((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id Nr) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id Nr) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3023,7 +3039,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UVector) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id ma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id ma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3036,7 +3052,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id phi_beta) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id phi_beta) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3056,7 +3072,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma2) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma2) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3074,7 +3090,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id Intercept) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id Intercept) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3131,7 +3147,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UVector) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id theta) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id theta) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3481,7 +3497,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UMatrix) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id phi) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id phi) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3500,7 +3516,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -4245,7 +4261,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UVector) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id ma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id ma) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -4258,7 +4274,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id phi_beta) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id phi_beta) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -4278,7 +4294,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma2) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma2) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -4296,7 +4312,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id Intercept) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id Intercept) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -4353,7 +4369,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UVector) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id theta) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id theta) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -4703,7 +4719,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UMatrix) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id phi) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id phi) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -4722,7 +4738,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -5467,7 +5483,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UVector) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id ma) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id ma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -5480,7 +5496,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id phi_beta) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id phi_beta) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -5500,7 +5516,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id sigma2) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id sigma2) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -5518,7 +5534,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id Intercept) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id Intercept) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -5575,7 +5591,7 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UVector) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id theta) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id theta) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -5925,11 +5941,11 @@ vector[Nr] h_sigma: SoA
        (meta ((type_ UMatrix) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id phi) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id phi) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id sigma) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id sigma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -6714,7 +6730,7 @@ vector[Nr] h_sigma: SoA
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -7022,7 +7038,7 @@ vector[Nr] h_sigma: SoA
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id ma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id ma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -7048,7 +7064,7 @@ vector[Nr] h_sigma: SoA
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id phi_beta) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id phi_beta) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -7081,7 +7097,7 @@ vector[Nr] h_sigma: SoA
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma2) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma2) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -7112,7 +7128,7 @@ vector[Nr] h_sigma: SoA
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id Intercept) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id Intercept) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -7291,7 +7307,7 @@ vector[Nr] h_sigma: SoA
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id theta) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id theta) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -8332,7 +8348,7 @@ vector[Nr] h_sigma: SoA
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id ma) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id ma) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -8349,7 +8365,7 @@ vector[Nr] h_sigma: SoA
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id phi_beta) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id phi_beta) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -8373,7 +8389,7 @@ vector[Nr] h_sigma: SoA
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sigma2) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sigma2) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -8395,7 +8411,7 @@ vector[Nr] h_sigma: SoA
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id Intercept) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id Intercept) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -8465,7 +8481,7 @@ vector[Nr] h_sigma: SoA
       ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id theta) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id theta) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -8841,14 +8857,15 @@ vector[Nr] h_sigma: SoA
       ((filename constraints.stan) (line_num 24) (col_num 2) (included_from ())))
      (end_loc
       ((filename constraints.stan) (line_num 24) (col_num 10) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
-     (out_trans Identity)))
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters) (out_trans Identity)))
    (phi_beta
     ((begin_loc
       ((filename constraints.stan) (line_num 25) (col_num 2) (included_from ())))
      (end_loc
       ((filename constraints.stan) (line_num 25) (col_num 33) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters)
      (out_trans
       (LowerUpper
        ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -8858,7 +8875,8 @@ vector[Nr] h_sigma: SoA
       ((filename constraints.stan) (line_num 26) (col_num 2) (included_from ())))
      (end_loc
       ((filename constraints.stan) (line_num 26) (col_num 23) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters)
      (out_trans
       (Lower
        ((pattern (Lit Int 0)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
@@ -8867,8 +8885,8 @@ vector[Nr] h_sigma: SoA
       ((filename constraints.stan) (line_num 27) (col_num 2) (included_from ())))
      (end_loc
       ((filename constraints.stan) (line_num 27) (col_num 17) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
-     (out_trans Identity)))
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters) (out_trans Identity)))
    (mean_price
     ((begin_loc
       ((filename constraints.stan) (line_num 28) (col_num 2) (included_from ())))
@@ -8902,8 +8920,8 @@ vector[Nr] h_sigma: SoA
       ((filename constraints.stan) (line_num 30) (col_num 2) (included_from ())))
      (end_loc
       ((filename constraints.stan) (line_num 30) (col_num 13) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
-     (out_trans Identity)))
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters) (out_trans Identity)))
    (upper_test
     ((begin_loc
       ((filename constraints.stan) (line_num 31) (col_num 2) (included_from ())))
@@ -9160,7 +9178,7 @@ vector[Nr] h_sigma: SoA
       ((filename constraints.stan) (line_num 47) (col_num 2) (included_from ())))
      (end_loc
       ((filename constraints.stan) (line_num 47) (col_num 56) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
      (out_block TransformedParameters)
      (out_trans
       (LowerUpper
@@ -9175,7 +9193,7 @@ vector[Nr] h_sigma: SoA
       ((filename constraints.stan) (line_num 48) (col_num 2) (included_from ())))
      (end_loc
       ((filename constraints.stan) (line_num 48) (col_num 37) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
      (out_block TransformedParameters)
      (out_trans
       (Lower
@@ -9965,7 +9983,7 @@ matrix[10, 10] X_tp7: AoS
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -10206,7 +10224,9 @@ matrix[10, 10] X_tp7: AoS
        ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block TransformedParameters) (out_trans Identity)))))
  (prog_name deep_dependence_model) (prog_path deep_dependence.stan))
+SoA (Line 19) warning: Accessed by element in a for loop: X_tp7
   $ ../../../../../../install/default/bin/stanc -fsoa --debug-optimized-mir --debug-mem-patterns indexing.stan
+real alpha: SoA
 vector[M] p_soa_vec_v: SoA
 matrix[N, M] p_soa_mat: SoA
 array[vector[N], 10] p_soa_arr_vec_v: SoA
@@ -10227,6 +10247,7 @@ matrix[N, M] p_aos_mat_pass_func_outer_single_indexed1: AoS
 matrix[N, M] p_aos_mat_pass_func_outer_single_indexed2: AoS
 matrix[N, M] p_aos_mat_fail_uni_uni_idx1: AoS
 matrix[N, M] p_aos_mat_fail_uni_uni_idx2: AoS
+real tp_real_from_aos: SoA
 vector[M] tp_aos_vec_v: AoS
 vector[M] tp_soa_single_idx_uninit: SoA
 vector[M] tp_aos_fail_func_vec_v: AoS
@@ -10264,11 +10285,11 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
   ((N
     ((begin_loc ((filename indexing.stan) (line_num 11) (col_num 1) (included_from ())))
      (end_loc ((filename indexing.stan) (line_num 11) (col_num 7) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (M
     ((begin_loc ((filename indexing.stan) (line_num 12) (col_num 1) (included_from ())))
      (end_loc ((filename indexing.stan) (line_num 12) (col_num 7) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (dat_x
     ((begin_loc ((filename indexing.stan) (line_num 13) (col_num 1) (included_from ())))
      (end_loc ((filename indexing.stan) (line_num 13) (col_num 20) (included_from ()))))
@@ -10283,11 +10304,11 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
    (idx_tester
     ((begin_loc ((filename indexing.stan) (line_num 15) (col_num 1) (included_from ())))
      (end_loc ((filename indexing.stan) (line_num 15) (col_num 25) (included_from ()))))
-    (SArray SInt
+    (SArray AoS (SInt AoS)
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -10295,7 +10316,8 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
       ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable N) ()) UInt
@@ -10312,7 +10334,8 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
        (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id M) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id M) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable M) ()) UInt
@@ -10507,7 +10530,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
      (Decl (decl_adtype DataOnly) (decl_id idx_tester)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -10759,7 +10782,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
     (meta <opaque>))))
  (log_prob
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -10817,7 +10840,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
      (Decl (decl_adtype AutoDiffable) (decl_id p_soa_arr_vec_v)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -11197,7 +11220,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype AutoDiffable) (decl_id tp_real_from_aos)
-      (decl_type (Sized SReal)) (initialize true)))
+      (decl_type (Sized (SReal AoS))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable tp_real_from_aos) ()) UReal
@@ -12147,7 +12170,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
     (meta <opaque>))))
  (reverse_mode_log_prob
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -12205,7 +12228,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
      (Decl (decl_adtype AutoDiffable) (decl_id p_soa_arr_vec_v)
       (decl_type
        (Sized
-        (SArray
+        (SArray SoA
          (SVector SoA
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -12585,7 +12608,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype AutoDiffable) (decl_id tp_real_from_aos)
-      (decl_type (Sized SReal)) (initialize true)))
+      (decl_type (Sized (SReal SoA))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable tp_real_from_aos) ()) UReal
@@ -13535,7 +13558,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
     (meta <opaque>))))
  (generate_quantities
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -13593,7 +13616,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
      (Decl (decl_adtype DataOnly) (decl_id p_soa_arr_vec_v)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -13972,8 +13995,8 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
        (meta ((type_ UMatrix) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id tp_real_from_aos) (decl_type (Sized SReal))
-      (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id tp_real_from_aos)
+      (decl_type (Sized (SReal AoS))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype DataOnly) (decl_id tp_aos_vec_v)
@@ -14390,7 +14413,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -14398,7 +14421,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
       ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -14593,7 +14616,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
      (Decl (decl_adtype AutoDiffable) (decl_id p_soa_arr_vec_v)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -16122,7 +16145,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
     (meta <opaque>))))
  (unconstrain_array
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16192,7 +16215,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
      (Decl (decl_adtype AutoDiffable) (decl_id p_soa_arr_vec_v)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (SVector AoS
           ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -16673,8 +16696,8 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
   ((alpha
     ((begin_loc ((filename indexing.stan) (line_num 19) (col_num 2) (included_from ())))
      (end_loc ((filename indexing.stan) (line_num 19) (col_num 13) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
-     (out_trans Identity)))
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters) (out_trans Identity)))
    (p_soa_vec_v
     ((begin_loc ((filename indexing.stan) (line_num 21) (col_num 2) (included_from ())))
      (end_loc ((filename indexing.stan) (line_num 21) (col_num 24) (included_from ()))))
@@ -16701,12 +16724,12 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
     ((begin_loc ((filename indexing.stan) (line_num 23) (col_num 2) (included_from ())))
      (end_loc ((filename indexing.stan) (line_num 23) (col_num 38) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (SVector AoS
         ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
@@ -16902,7 +16925,7 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
    (tp_real_from_aos
     ((begin_loc ((filename indexing.stan) (line_num 56) (col_num 2) (included_from ())))
      (end_loc ((filename indexing.stan) (line_num 56) (col_num 41) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
      (out_block TransformedParameters) (out_trans Identity)))
    (tp_aos_vec_v
     ((begin_loc ((filename indexing.stan) (line_num 59) (col_num 2) (included_from ())))
@@ -16945,7 +16968,18 @@ vector[N] tp_aos_loop_vec_v_multi_uni_idx: AoS
        ((pattern (Var M)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block TransformedParameters) (out_trans Identity)))))
  (prog_name indexing_model) (prog_path indexing.stan))
+SoA (Line 59) warning: Right hand side of assignment is all AoS: p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 59) warning: Function on right hand side of assignment is not supported by SoA: p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 80) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 81) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 82) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 83) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 101) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 101) warning: Used in user defined function:p_aos_vec_v_assign_to_aos, tp_aos_vec_v
+SoA (Line 111) warning: Accessed by element in a for loop: tp_aos_loop_vec_v_uni_idx
+SoA (Line 112) warning: Accessed by element in a for loop: tp_aos_loop_vec_v_multi_uni_idx
   $ ../../../../../../install/default/bin/stanc -fsoa --debug-optimized-mir --debug-mem-patterns indexing2.stan
+real alpha: SoA
 vector[10] p_aos_loop_single_idx: AoS
 vector[N] tp_soa_multi_idx_assign_in_loop: SoA
 vector[N] tp_soa_single_idx_in_upfrom_idx: SoA
@@ -16954,19 +16988,20 @@ vector[N] tp_soa_single_idx_in_upfrom_idx: SoA
   ((N
     ((begin_loc ((filename indexing2.stan) (line_num 2) (col_num 1) (included_from ())))
      (end_loc ((filename indexing2.stan) (line_num 2) (col_num 7) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (M
     ((begin_loc ((filename indexing2.stan) (line_num 3) (col_num 1) (included_from ())))
      (end_loc ((filename indexing2.stan) (line_num 3) (col_num 7) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (Idx
     ((begin_loc ((filename indexing2.stan) (line_num 4) (col_num 1) (included_from ())))
      (end_loc ((filename indexing2.stan) (line_num 4) (col_num 18) (included_from ()))))
-    (SArray SInt
+    (SArray AoS (SInt AoS)
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable N) ()) UInt
@@ -16983,7 +17018,8 @@ vector[N] tp_soa_single_idx_in_upfrom_idx: SoA
        (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id M) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id M) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable M) ()) UInt
@@ -17009,7 +17045,7 @@ vector[N] tp_soa_single_idx_in_upfrom_idx: SoA
      (Decl (decl_adtype DataOnly) (decl_id Idx)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -17023,7 +17059,7 @@ vector[N] tp_soa_single_idx_in_upfrom_idx: SoA
     (meta <opaque>))))
  (log_prob
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -17162,7 +17198,7 @@ vector[N] tp_soa_single_idx_in_upfrom_idx: SoA
     (meta <opaque>))))
  (reverse_mode_log_prob
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -17301,7 +17337,7 @@ vector[N] tp_soa_single_idx_in_upfrom_idx: SoA
     (meta <opaque>))))
  (generate_quantities
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -17376,7 +17412,7 @@ vector[N] tp_soa_single_idx_in_upfrom_idx: SoA
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -17384,7 +17420,7 @@ vector[N] tp_soa_single_idx_in_upfrom_idx: SoA
       ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -17486,7 +17522,7 @@ vector[N] tp_soa_single_idx_in_upfrom_idx: SoA
     (meta <opaque>))))
  (unconstrain_array
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id alpha) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -17531,8 +17567,8 @@ vector[N] tp_soa_single_idx_in_upfrom_idx: SoA
   ((alpha
     ((begin_loc ((filename indexing2.stan) (line_num 8) (col_num 2) (included_from ())))
      (end_loc ((filename indexing2.stan) (line_num 8) (col_num 13) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
-     (out_trans Identity)))
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters) (out_trans Identity)))
    (p_aos_loop_single_idx
     ((begin_loc ((filename indexing2.stan) (line_num 9) (col_num 2) (included_from ())))
      (end_loc ((filename indexing2.stan) (line_num 9) (col_num 35) (included_from ()))))
@@ -17548,6 +17584,7 @@ vector[N] tp_soa_single_idx_in_upfrom_idx: SoA
 matrix[5, 10] soa_x: SoA
 matrix[5, 10] aos_x: AoS
 matrix[5, 10] aos_y: AoS
+real tp_real_from_soa: SoA
 matrix[5, 10] tp_matrix_aos_from_mix: AoS
 matrix[5, 10] tp_matrix_from_udf_reduced_soa: AoS
 ((functions_block
@@ -17586,10 +17623,10 @@ matrix[5, 10] tp_matrix_from_udf_reduced_soa: AoS
       ((filename reductions_allowed.stan) (line_num 12) (col_num 4) (included_from ())))
      (end_loc
       ((filename reductions_allowed.stan) (line_num 12) (col_num 16) (included_from ()))))
-    SReal)))
+    (SReal AoS))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id data_r) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id data_r) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -17681,7 +17718,7 @@ matrix[5, 10] tp_matrix_from_udf_reduced_soa: AoS
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype AutoDiffable) (decl_id tp_real_from_soa)
-      (decl_type (Sized SReal)) (initialize true)))
+      (decl_type (Sized (SReal AoS))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable tp_real_from_soa) ()) UReal
@@ -17841,7 +17878,7 @@ matrix[5, 10] tp_matrix_from_udf_reduced_soa: AoS
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype AutoDiffable) (decl_id tp_real_from_soa)
-      (decl_type (Sized SReal)) (initialize true)))
+      (decl_type (Sized (SReal SoA))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable tp_real_from_soa) ()) UReal
@@ -18000,8 +18037,8 @@ matrix[5, 10] tp_matrix_from_udf_reduced_soa: AoS
        (meta ((type_ UMatrix) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id tp_real_from_soa) (decl_type (Sized SReal))
-      (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id tp_real_from_soa)
+      (decl_type (Sized (SReal AoS))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype DataOnly) (decl_id tp_matrix_aos_from_mix)
@@ -18174,7 +18211,7 @@ matrix[5, 10] tp_matrix_from_udf_reduced_soa: AoS
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -18590,7 +18627,7 @@ matrix[5, 10] tp_matrix_from_udf_reduced_soa: AoS
       ((filename reductions_allowed.stan) (line_num 22) (col_num 4) (included_from ())))
      (end_loc
       ((filename reductions_allowed.stan) (line_num 22) (col_num 56) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
      (out_block TransformedParameters) (out_trans Identity)))
    (tp_matrix_aos_from_mix
     ((begin_loc
@@ -18621,6 +18658,10 @@ matrix[5, 10] tp_matrix_from_udf_reduced_soa: AoS
        ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block TransformedParameters) (out_trans Identity)))))
  (prog_name reductions_allowed_model) (prog_path reductions_allowed.stan))
+SoA (Line 23) warning: Right hand side of assignment is all AoS: aos_x, aos_y, tp_matrix_aos_from_mix
+SoA (Line 24) warning: Used in user defined function:aos_x, aos_y, tp_matrix_aos_from_mix
+SoA (Line 24) warning: Right hand side of assignment is all AoS: aos_x, tp_matrix_from_udf_reduced_soa
+SoA (Line 24) warning: Function on right hand side of assignment is not supported by SoA: aos_x, tp_matrix_from_udf_reduced_soa
   $ ../../../../../../install/default/bin/stanc -fsoa --debug-optimized-mir --debug-mem-patterns return_types_and_udfs_demotes.stan
 matrix[10, 10] row_soa: SoA
 matrix[10, 10] udf_input_aos: AoS
@@ -19240,7 +19281,7 @@ matrix[10, 10] mul_two_aos: AoS
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -19605,9 +19646,18 @@ matrix[10, 10] mul_two_aos: AoS
      (out_block TransformedParameters) (out_trans Identity)))))
  (prog_name return_types_and_udfs_demotes_model)
  (prog_path return_types_and_udfs_demotes.stan))
+SoA (Line 25) warning: Right hand side of assignment is all AoS: udf_input_aos, user_func_aos
+SoA (Line 25) warning: Function on right hand side of assignment is not supported by SoA: udf_input_aos, user_func_aos
+SoA (Line 26) warning: Used in user defined function:udf_input_aos, user_func_aos
+SoA (Line 26) warning: Function on right hand side of assignment is not supported by SoA: empty_user_func_aos
+SoA (Line 27) warning: Used in user defined function:empty_user_func_aos, udf_input_aos, user_func_aos
+SoA (Line 27) warning: Right hand side of assignment is all AoS: inner_empty_user_func_aos, udf_input_aos
+SoA (Line 28) warning: Right hand side of assignment is all AoS: empty_user_func_aos, int_aos_mul_aos
+SoA (Line 29) warning: Right hand side of assignment is all AoS: int_aos_mul_aos, mul_two_aos, user_func_aos
   $ ../../../../../../install/default/bin/stanc -fsoa --debug-optimized-mir --debug-mem-patterns single_indexing.stan
 matrix[10, 10] aos_p: AoS
 matrix[10, 10] soa_p: SoA
+real tp_real_from_soa: SoA
 row_vector[10] tp_row_vector_from_soa_loop: SoA
 matrix[10, 10] tp_matrix_from_soa_loop: SoA
 ((functions_block ()) (input_vars ()) (prepare_data ())
@@ -19662,7 +19712,7 @@ matrix[10, 10] tp_matrix_from_soa_loop: SoA
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype AutoDiffable) (decl_id tp_real_from_soa)
-      (decl_type (Sized SReal)) (initialize true)))
+      (decl_type (Sized (SReal AoS))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable tp_real_from_soa) ()) UReal
@@ -19795,7 +19845,7 @@ matrix[10, 10] tp_matrix_from_soa_loop: SoA
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype AutoDiffable) (decl_id tp_real_from_soa)
-      (decl_type (Sized SReal)) (initialize true)))
+      (decl_type (Sized (SReal SoA))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable tp_real_from_soa) ()) UReal
@@ -19927,8 +19977,8 @@ matrix[10, 10] tp_matrix_from_soa_loop: SoA
        (meta ((type_ UMatrix) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id tp_real_from_soa) (decl_type (Sized SReal))
-      (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id tp_real_from_soa)
+      (decl_type (Sized (SReal AoS))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (NRFunApp
@@ -20071,7 +20121,7 @@ matrix[10, 10] tp_matrix_from_soa_loop: SoA
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -20355,7 +20405,7 @@ matrix[10, 10] tp_matrix_from_soa_loop: SoA
       ((filename single_indexing.stan) (line_num 11) (col_num 5) (included_from ())))
      (end_loc
       ((filename single_indexing.stan) (line_num 11) (col_num 41) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
      (out_block TransformedParameters) (out_trans Identity)))))
  (prog_name single_indexing_model) (prog_path single_indexing.stan))
   $ ../../../../../../install/default/bin/stanc -fsoa --debug-optimized-mir --debug-mem-patterns tp_reused.stan
@@ -20396,10 +20446,10 @@ matrix[5, 10] tp_matrix_aos: AoS
   ((data_r
     ((begin_loc ((filename tp_reused.stan) (line_num 12) (col_num 4) (included_from ())))
      (end_loc ((filename tp_reused.stan) (line_num 12) (col_num 16) (included_from ()))))
-    SReal)))
+    (SReal AoS))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id data_r) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id data_r) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -20690,7 +20740,7 @@ matrix[5, 10] tp_matrix_aos: AoS
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -20976,6 +21026,8 @@ matrix[5, 10] tp_matrix_aos: AoS
        ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block TransformedParameters) (out_trans Identity)))))
  (prog_name tp_reused_model) (prog_path tp_reused.stan))
+SoA (Line 22) warning: Right hand side of assignment is all AoS: aos_x, tp_matrix_aos
+SoA (Line 22) warning: Function on right hand side of assignment is not supported by SoA: aos_x, tp_matrix_aos
   $ ../../../../../../install/default/bin/stanc -fsoa --debug-optimized-mir --debug-mem-patterns tuple_test.stan
 tuple(array[matrix[1, 1], 1], matrix[1, 2], matrix[1, 3]) xx: AoS
 matrix[1, 1] x: AoS
@@ -21030,7 +21082,7 @@ matrix[1, 1] x: AoS
       (decl_type
        (Sized
         (STuple
-         ((SArray
+         ((SArray AoS
            (SMatrix AoS
             ((pattern (Lit Int 1))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -21130,7 +21182,7 @@ matrix[1, 1] x: AoS
       (decl_type
        (Sized
         (STuple
-         ((SArray
+         ((SArray AoS
            (SMatrix AoS
             ((pattern (Lit Int 1))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -21229,7 +21281,7 @@ matrix[1, 1] x: AoS
       (decl_type
        (Sized
         (STuple
-         ((SArray
+         ((SArray AoS
            (SMatrix AoS
             ((pattern (Lit Int 1))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -21466,7 +21518,7 @@ matrix[1, 1] x: AoS
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -21479,7 +21531,7 @@ matrix[1, 1] x: AoS
       (decl_type
        (Sized
         (STuple
-         ((SArray
+         ((SArray AoS
            (SMatrix AoS
             ((pattern (Lit Int 1))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -21801,7 +21853,7 @@ matrix[1, 1] x: AoS
       (decl_type
        (Sized
         (STuple
-         ((SArray
+         ((SArray AoS
            (SMatrix AoS
             ((pattern (Lit Int 1))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -21943,7 +21995,7 @@ matrix[1, 1] x: AoS
      (end_loc ((filename tuple_test.stan) (line_num 3) (col_num 61) (included_from ()))))
     ((out_unconstrained_st
       (STuple
-       ((SArray
+       ((SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -21956,7 +22008,7 @@ matrix[1, 1] x: AoS
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
      (out_constrained_st
       (STuple
-       ((SArray
+       ((SArray AoS
          (SMatrix AoS
           ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
           ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -21982,3 +22034,5 @@ matrix[1, 1] x: AoS
        ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block TransformedParameters) (out_trans Identity)))))
  (prog_name tuple_test_model) (prog_path tuple_test.stan))
+SoA (Line 6) warning: Right hand side of assignment is all AoS: x, xx
+SoA (Line 6) warning: The right hand side of the assignment only contains data and scalar operations that are not promotable to SoA: x, xx
diff --git a/test/integration/good/tuples/transformed_mir.expected b/test/integration/good/tuples/transformed_mir.expected
index d0ae07810..2298f7aef 100644
--- a/test/integration/good/tuples/transformed_mir.expected
+++ b/test/integration/good/tuples/transformed_mir.expected
@@ -7,18 +7,18 @@
      (end_loc
       ((filename arrays-tuples-nested.stan) (line_num 2) (col_num 35) (included_from ()))))
     (STuple
-     ((SArray SReal
+     ((SArray AoS (SReal AoS)
        ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-      SInt)))
+      (SInt AoS))))
    (tuple_tuple
     ((begin_loc
       ((filename arrays-tuples-nested.stan) (line_num 3) (col_num 2) (included_from ())))
      (end_loc
       ((filename arrays-tuples-nested.stan) (line_num 3) (col_num 49) (included_from ()))))
     (STuple
-     (SInt
+     ((SInt AoS)
       (STuple
-       (SReal
+       ((SReal AoS)
         (SVector AoS
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))))
    (arr_tuple
@@ -26,10 +26,10 @@
       ((filename arrays-tuples-nested.stan) (line_num 4) (col_num 2) (included_from ())))
      (end_loc
       ((filename arrays-tuples-nested.stan) (line_num 4) (col_num 58) (included_from ()))))
-    (SArray
+    (SArray AoS
      (STuple
-      (SInt
-       (SArray SReal
+      ((SInt AoS)
+       (SArray AoS (SReal AoS)
         ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        (SVector AoS
         ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -40,13 +40,13 @@
      (end_loc
       ((filename arrays-tuples-nested.stan) (line_num 5) (col_num 80) (included_from ()))))
     (STuple
-     ((SArray SReal
+     ((SArray AoS (SReal AoS)
        ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-      SInt
-      (SArray
+      (SInt AoS)
+      (SArray AoS
        (STuple
-        (SReal
-         (SArray SInt
+        ((SReal AoS)
+         (SArray AoS (SInt AoS)
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
    (arr_tuple_tuple
@@ -54,13 +54,13 @@
       ((filename arrays-tuples-nested.stan) (line_num 6) (col_num 2) (included_from ())))
      (end_loc
       ((filename arrays-tuples-nested.stan) (line_num 6) (col_num 80) (included_from ()))))
-    (SArray
+    (SArray AoS
      (STuple
-      (SReal SInt
+      ((SReal AoS) (SInt AoS)
        (STuple
-        (SReal
+        ((SReal AoS)
          (STuple
-          (SInt
+          ((SInt AoS)
            (SVector AoS
             ((pattern (Lit Int 4))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))))
@@ -70,12 +70,12 @@
       ((filename arrays-tuples-nested.stan) (line_num 7) (col_num 2) (included_from ())))
      (end_loc
       ((filename arrays-tuples-nested.stan) (line_num 7) (col_num 75) (included_from ()))))
-    (SArray
+    (SArray AoS
      (STuple
-      (SInt
-       (SArray
+      ((SInt AoS)
+       (SArray AoS
         (STuple
-         (SReal
+         ((SReal AoS)
           (SVector AoS
            ((pattern (Lit Int 5))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -86,13 +86,13 @@
       ((filename arrays-tuples-nested.stan) (line_num 8) (col_num 2) (included_from ())))
      (end_loc
       ((filename arrays-tuples-nested.stan) (line_num 9) (col_num 79) (included_from ()))))
-    (SArray
+    (SArray AoS
      (STuple
-      (SInt
-       (SArray
+      ((SInt AoS)
+       (SArray AoS
         (STuple
-         (SReal
-          (SArray
+         ((SReal AoS)
+          (SArray AoS
            (STuple
             (SComplex
              (SMatrix AoS
@@ -106,7 +106,7 @@
      ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -118,10 +118,10 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 10))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SInt))))
+          (SInt AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -152,9 +152,9 @@
       (decl_type
        (Sized
         (STuple
-         (SInt
+         ((SInt AoS)
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))))
@@ -254,10 +254,10 @@
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly DataOnly))) (decl_id arr_tuple)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SInt
-           (SArray SReal
+          ((SInt AoS)
+           (SArray AoS (SReal AoS)
             ((pattern (Lit Int 4))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            (SVector AoS
@@ -336,13 +336,13 @@
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id arr_tuple_dot_1_temp__)
-          (decl_type (Sized SInt)) (initialize true)))
+          (decl_type (Sized (SInt AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id arr_tuple_dot_2_temp__)
           (decl_type
            (Sized
-            (SArray SReal
+            (SArray AoS (SReal AoS)
              ((pattern (Lit Int 4))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
           (initialize true)))
@@ -548,14 +548,14 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SInt
-          (SArray
+          (SInt AoS)
+          (SArray AoS
            (STuple
-            (SReal
-             (SArray SInt
+            ((SReal AoS)
+             (SArray AoS (SInt AoS)
               ((pattern (Lit Int 4))
                (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
            ((pattern (Lit Int 3))
@@ -634,13 +634,13 @@
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id tuple_arr_tuple_dot_3_dot_1_temp__)
-          (decl_type (Sized SReal)) (initialize true)))
+          (decl_type (Sized (SReal AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id tuple_arr_tuple_dot_3_dot_2_temp__)
           (decl_type
            (Sized
-            (SArray SInt
+            (SArray AoS (SInt AoS)
              ((pattern (Lit Int 4))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
           (initialize true)))
@@ -742,13 +742,13 @@
       (decl_id arr_tuple_tuple)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal SInt
+          ((SReal AoS) (SInt AoS)
            (STuple
-            (SReal
+            ((SReal AoS)
              (STuple
-              (SInt
+              ((SInt AoS)
                (SVector AoS
                 ((pattern (Lit Int 4))
                  (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))))
@@ -878,11 +878,11 @@
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id arr_tuple_tuple_dot_1_temp__)
-          (decl_type (Sized SReal)) (initialize true)))
+          (decl_type (Sized (SReal AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id arr_tuple_tuple_dot_2_temp__)
-          (decl_type (Sized SInt)) (initialize true)))
+          (decl_type (Sized (SInt AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype (TupleAD (DataOnly (TupleAD (DataOnly DataOnly)))))
@@ -890,9 +890,9 @@
           (decl_type
            (Sized
             (STuple
-             (SReal
+             ((SReal AoS)
               (STuple
-               (SInt
+               ((SInt AoS)
                 (SVector AoS
                  ((pattern (Lit Int 4))
                   (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))))
@@ -1157,12 +1157,12 @@
       (decl_id arr_tuple_arr_tuple)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SInt
-           (SArray
+          ((SInt AoS)
+           (SArray AoS
             (STuple
-             (SReal
+             ((SReal AoS)
               (SVector AoS
                ((pattern (Lit Int 5))
                 (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -1247,16 +1247,16 @@
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id arr_tuple_arr_tuple_dot_1_temp__)
-          (decl_type (Sized SInt)) (initialize true)))
+          (decl_type (Sized (SInt AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype (TupleAD (DataOnly DataOnly)))
           (decl_id arr_tuple_arr_tuple_dot_2_temp__)
           (decl_type
            (Sized
-            (SArray
+            (SArray AoS
              (STuple
-              (SReal
+              ((SReal AoS)
                (SVector AoS
                 ((pattern (Lit Int 5))
                  (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -1301,7 +1301,7 @@
                   (((pattern
                      (Decl (decl_adtype DataOnly)
                       (decl_id arr_tuple_arr_tuple_dot_2_dot_1_temp__)
-                      (decl_type (Sized SReal)) (initialize true)))
+                      (decl_type (Sized (SReal AoS))) (initialize true)))
                     (meta <opaque>))
                    ((pattern
                      (Decl (decl_adtype DataOnly)
@@ -1546,13 +1546,13 @@
       (decl_id very_deep)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SInt
-           (SArray
+          ((SInt AoS)
+           (SArray AoS
             (STuple
-             (SReal
-              (SArray
+             ((SReal AoS)
+              (SArray AoS
                (STuple
                 (SComplex
                  (SMatrix AoS
@@ -1673,17 +1673,17 @@
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id very_deep_dot_1_temp__)
-          (decl_type (Sized SInt)) (initialize true)))
+          (decl_type (Sized (SInt AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype (TupleAD (DataOnly (TupleAD (DataOnly DataOnly)))))
           (decl_id very_deep_dot_2_temp__)
           (decl_type
            (Sized
-            (SArray
+            (SArray AoS
              (STuple
-              (SReal
-               (SArray
+              ((SReal AoS)
+               (SArray AoS
                 (STuple
                  (SComplex
                   (SMatrix AoS
@@ -1733,14 +1733,14 @@
                  (Block
                   (((pattern
                      (Decl (decl_adtype DataOnly) (decl_id very_deep_dot_2_dot_1_temp__)
-                      (decl_type (Sized SReal)) (initialize true)))
+                      (decl_type (Sized (SReal AoS))) (initialize true)))
                     (meta <opaque>))
                    ((pattern
                      (Decl (decl_adtype (TupleAD (DataOnly DataOnly)))
                       (decl_id very_deep_dot_2_dot_2_temp__)
                       (decl_type
                        (Sized
-                        (SArray
+                        (SArray AoS
                          (STuple
                           (SComplex
                            (SMatrix AoS
@@ -2179,10 +2179,10 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 10))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal))))
+          (SReal AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -2213,9 +2213,9 @@
       (decl_type
        (Sized
         (STuple
-         (SReal
+         ((SReal AoS)
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))))
@@ -2261,10 +2261,10 @@
       (decl_id arr_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
           (SComplex
-           (SArray SReal
+           (SArray AoS (SReal AoS)
             ((pattern (Lit Int 4))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            (SVector AoS
@@ -2351,14 +2351,14 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal
-          (SArray
+          (SReal AoS)
+          (SArray AoS
            (STuple
-            (SReal
-             (SArray SReal
+            ((SReal AoS)
+             (SArray AoS (SReal AoS)
               ((pattern (Lit Int 4))
                (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
            ((pattern (Lit Int 3))
@@ -2446,11 +2446,11 @@
       (decl_id arr_tuple_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal SReal
+          ((SReal AoS) (SReal AoS)
            (STuple
-            (SReal
+            ((SReal AoS)
              (STuple
               (SComplex
                (SVector AoS
@@ -2579,12 +2579,12 @@
       (decl_id arr_tuple_arr_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
+             ((SReal AoS)
               (SVector AoS
                ((pattern (Lit Int 5))
                 (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -2690,13 +2690,13 @@
       (decl_id very_deep_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
-              (SArray
+             ((SReal AoS)
+              (SArray AoS
                (STuple
                 (SComplex
                  (SMatrix AoS
@@ -2864,10 +2864,10 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 10))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal))))
+          (SReal AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -2898,9 +2898,9 @@
       (decl_type
        (Sized
         (STuple
-         (SReal
+         ((SReal AoS)
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))))
@@ -2946,10 +2946,10 @@
       (decl_id arr_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
           (SComplex
-           (SArray SReal
+           (SArray AoS (SReal AoS)
             ((pattern (Lit Int 4))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            (SVector AoS
@@ -3036,14 +3036,14 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal
-          (SArray
+          (SReal AoS)
+          (SArray AoS
            (STuple
-            (SReal
-             (SArray SReal
+            ((SReal AoS)
+             (SArray AoS (SReal AoS)
               ((pattern (Lit Int 4))
                (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
            ((pattern (Lit Int 3))
@@ -3131,11 +3131,11 @@
       (decl_id arr_tuple_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal SReal
+          ((SReal AoS) (SReal AoS)
            (STuple
-            (SReal
+            ((SReal AoS)
              (STuple
               (SComplex
                (SVector AoS
@@ -3264,12 +3264,12 @@
       (decl_id arr_tuple_arr_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
+             ((SReal AoS)
               (SVector AoS
                ((pattern (Lit Int 5))
                 (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -3375,13 +3375,13 @@
       (decl_id very_deep_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
-              (SArray
+             ((SReal AoS)
+              (SArray AoS
                (STuple
                 (SComplex
                  (SMatrix AoS
@@ -3549,10 +3549,10 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 10))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal))))
+          (SReal AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -3583,9 +3583,9 @@
       (decl_type
        (Sized
         (STuple
-         (SReal
+         ((SReal AoS)
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))))
@@ -3630,10 +3630,10 @@
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly DataOnly))) (decl_id arr_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
           (SComplex
-           (SArray SReal
+           (SArray AoS (SReal AoS)
             ((pattern (Lit Int 4))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            (SVector AoS
@@ -3718,14 +3718,14 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal
-          (SArray
+          (SReal AoS)
+          (SArray AoS
            (STuple
-            (SReal
-             (SArray SReal
+            ((SReal AoS)
+             (SArray AoS (SReal AoS)
               ((pattern (Lit Int 4))
                (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
            ((pattern (Lit Int 3))
@@ -3811,11 +3811,11 @@
       (decl_id arr_tuple_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal SReal
+          ((SReal AoS) (SReal AoS)
            (STuple
-            (SReal
+            ((SReal AoS)
              (STuple
               (SComplex
                (SVector AoS
@@ -3944,12 +3944,12 @@
       (decl_id arr_tuple_arr_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
+             ((SReal AoS)
               (SVector AoS
                ((pattern (Lit Int 5))
                 (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -4054,13 +4054,13 @@
       (decl_id very_deep_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
-              (SArray
+             ((SReal AoS)
+              (SArray AoS
                (STuple
                 (SComplex
                  (SMatrix AoS
@@ -5116,7 +5116,7 @@
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -5128,10 +5128,10 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 10))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal))))
+          (SReal AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -5190,9 +5190,9 @@
       (decl_type
        (Sized
         (STuple
-         (SReal
+         ((SReal AoS)
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))))
@@ -5346,10 +5346,10 @@
       (decl_id arr_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
           (SComplex
-           (SArray SReal
+           (SArray AoS (SReal AoS)
             ((pattern (Lit Int 4))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            (SVector AoS
@@ -5434,7 +5434,7 @@
          (Decl (decl_adtype DataOnly) (decl_id arr_tuple_p_dot_2_temp__)
           (decl_type
            (Sized
-            (SArray SReal
+            (SArray AoS (SReal AoS)
              ((pattern (Lit Int 4))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
           (initialize true)))
@@ -5723,14 +5723,14 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal
-          (SArray
+          (SReal AoS)
+          (SArray AoS
            (STuple
-            (SReal
-             (SArray SReal
+            ((SReal AoS)
+             (SArray AoS (SReal AoS)
               ((pattern (Lit Int 4))
                (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
            ((pattern (Lit Int 3))
@@ -5809,13 +5809,13 @@
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id tuple_arr_tuple_p_dot_3_dot_1_temp__)
-          (decl_type (Sized SReal)) (initialize true)))
+          (decl_type (Sized (SReal AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id tuple_arr_tuple_p_dot_3_dot_2_temp__)
           (decl_type
            (Sized
-            (SArray SReal
+            (SArray AoS (SReal AoS)
              ((pattern (Lit Int 4))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
           (initialize true)))
@@ -6027,11 +6027,11 @@
       (decl_id arr_tuple_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal SReal
+          ((SReal AoS) (SReal AoS)
            (STuple
-            (SReal
+            ((SReal AoS)
              (STuple
               (SComplex
                (SVector AoS
@@ -6170,11 +6170,11 @@
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id arr_tuple_tuple_p_dot_1_temp__)
-          (decl_type (Sized SReal)) (initialize true)))
+          (decl_type (Sized (SReal AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id arr_tuple_tuple_p_dot_2_temp__)
-          (decl_type (Sized SReal)) (initialize true)))
+          (decl_type (Sized (SReal AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype (TupleAD (DataOnly (TupleAD (DataOnly DataOnly)))))
@@ -6182,7 +6182,7 @@
           (decl_type
            (Sized
             (STuple
-             (SReal
+             ((SReal AoS)
               (STuple
                (SComplex
                 (SVector AoS
@@ -6640,12 +6640,12 @@
       (decl_id arr_tuple_arr_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
+             ((SReal AoS)
               (SVector AoS
                ((pattern (Lit Int 5))
                 (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -6730,16 +6730,16 @@
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id arr_tuple_arr_tuple_p_dot_1_temp__)
-          (decl_type (Sized SReal)) (initialize true)))
+          (decl_type (Sized (SReal AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype (TupleAD (DataOnly DataOnly)))
           (decl_id arr_tuple_arr_tuple_p_dot_2_temp__)
           (decl_type
            (Sized
-            (SArray
+            (SArray AoS
              (STuple
-              (SReal
+              ((SReal AoS)
                (SVector AoS
                 ((pattern (Lit Int 5))
                  (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -6785,7 +6785,7 @@
                   (((pattern
                      (Decl (decl_adtype DataOnly)
                       (decl_id arr_tuple_arr_tuple_p_dot_2_dot_1_temp__)
-                      (decl_type (Sized SReal)) (initialize true)))
+                      (decl_type (Sized (SReal AoS))) (initialize true)))
                     (meta <opaque>))
                    ((pattern
                      (Decl (decl_adtype DataOnly)
@@ -7168,13 +7168,13 @@
       (decl_id very_deep_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
-              (SArray
+             ((SReal AoS)
+              (SArray AoS
                (STuple
                 (SComplex
                  (SMatrix AoS
@@ -7300,17 +7300,17 @@
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id very_deep_p_dot_1_temp__)
-          (decl_type (Sized SReal)) (initialize true)))
+          (decl_type (Sized (SReal AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype (TupleAD (DataOnly (TupleAD (DataOnly DataOnly)))))
           (decl_id very_deep_p_dot_2_temp__)
           (decl_type
            (Sized
-            (SArray
+            (SArray AoS
              (STuple
-              (SReal
-               (SArray
+              ((SReal AoS)
+               (SArray AoS
                 (STuple
                  (SComplex
                   (SMatrix AoS
@@ -7360,15 +7360,15 @@
                  (Block
                   (((pattern
                      (Decl (decl_adtype DataOnly)
-                      (decl_id very_deep_p_dot_2_dot_1_temp__) (decl_type (Sized SReal))
-                      (initialize true)))
+                      (decl_id very_deep_p_dot_2_dot_1_temp__)
+                      (decl_type (Sized (SReal AoS))) (initialize true)))
                     (meta <opaque>))
                    ((pattern
                      (Decl (decl_adtype (TupleAD (DataOnly DataOnly)))
                       (decl_id very_deep_p_dot_2_dot_2_temp__)
                       (decl_type
                        (Sized
-                        (SArray
+                        (SArray AoS
                          (STuple
                           (SComplex
                            (SMatrix AoS
@@ -8096,10 +8096,10 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 10))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal))))
+          (SReal AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -8149,9 +8149,9 @@
       (decl_type
        (Sized
         (STuple
-         (SReal
+         ((SReal AoS)
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))))
@@ -8236,10 +8236,10 @@
       (decl_id arr_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
           (SComplex
-           (SArray SReal
+           (SArray AoS (SReal AoS)
             ((pattern (Lit Int 4))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            (SVector AoS
@@ -8392,14 +8392,14 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal
-          (SArray
+          (SReal AoS)
+          (SArray AoS
            (STuple
-            (SReal
-             (SArray SReal
+            ((SReal AoS)
+             (SArray AoS (SReal AoS)
               ((pattern (Lit Int 4))
                (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
            ((pattern (Lit Int 3))
@@ -8575,11 +8575,11 @@
       (decl_id arr_tuple_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal SReal
+          ((SReal AoS) (SReal AoS)
            (STuple
-            (SReal
+            ((SReal AoS)
              (STuple
               (SComplex
                (SVector AoS
@@ -8871,12 +8871,12 @@
       (decl_id arr_tuple_arr_tuple_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
+             ((SReal AoS)
               (SVector AoS
                ((pattern (Lit Int 5))
                 (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -9101,13 +9101,13 @@
       (decl_id very_deep_p)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
-              (SArray
+             ((SReal AoS)
+              (SArray AoS
                (STuple
                 (SComplex
                  (SMatrix AoS
@@ -9546,14 +9546,14 @@
        (included_from ()))))
     ((out_unconstrained_st
       (STuple
-       ((SArray SReal
+       ((SArray AoS (SReal AoS)
          ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-        SReal)))
+        (SReal AoS))))
      (out_constrained_st
       (STuple
-       ((SArray SReal
+       ((SArray AoS (SReal AoS)
          ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-        SReal)))
+        (SReal AoS))))
      (out_block Parameters) (out_trans (TupleTransformation (Identity Identity)))))
    (tuple_tuple_p
     ((begin_loc
@@ -9563,17 +9563,17 @@
        (included_from ()))))
     ((out_unconstrained_st
       (STuple
-       (SReal
+       ((SReal AoS)
         (STuple
-         (SReal
+         ((SReal AoS)
           (SVector AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))))
      (out_constrained_st
       (STuple
-       (SReal
+       ((SReal AoS)
         (STuple
-         (SReal
+         ((SReal AoS)
           (SVector AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))))
@@ -9587,19 +9587,19 @@
       ((filename arrays-tuples-nested.stan) (line_num 14) (col_num 64)
        (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (STuple
         (SComplex
-         (SArray SReal
+         (SArray AoS (SReal AoS)
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          (SVector AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (STuple
         (SComplex
-         (SArray SReal
+         (SArray AoS (SReal AoS)
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
          (SVector AoS
           ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -9614,25 +9614,25 @@
        (included_from ()))))
     ((out_unconstrained_st
       (STuple
-       ((SArray SReal
+       ((SArray AoS (SReal AoS)
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-        SReal
-        (SArray
+        (SReal AoS)
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray SReal
+          ((SReal AoS)
+           (SArray AoS (SReal AoS)
             ((pattern (Lit Int 4))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
      (out_constrained_st
       (STuple
-       ((SArray SReal
+       ((SArray AoS (SReal AoS)
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-        SReal
-        (SArray
+        (SReal AoS)
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray SReal
+          ((SReal AoS)
+           (SArray AoS (SReal AoS)
             ((pattern (Lit Int 4))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
@@ -9646,11 +9646,11 @@
       ((filename arrays-tuples-nested.stan) (line_num 16) (col_num 87)
        (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (STuple
-        (SReal SReal
+        ((SReal AoS) (SReal AoS)
          (STuple
-          (SReal
+          ((SReal AoS)
            (STuple
             (SComplex
              (SVector AoS
@@ -9658,11 +9658,11 @@
                (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))))
        ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (STuple
-        (SReal SReal
+        ((SReal AoS) (SReal AoS)
          (STuple
-          (SReal
+          ((SReal AoS)
            (STuple
             (SComplex
              (SVector AoS
@@ -9681,24 +9681,24 @@
       ((filename arrays-tuples-nested.stan) (line_num 17) (col_num 78)
        (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (STuple
-        (SReal
-         (SArray
+        ((SReal AoS)
+         (SArray AoS
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 5))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (STuple
-        (SReal
-         (SArray
+        ((SReal AoS)
+         (SArray AoS
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 5))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -9714,13 +9714,13 @@
       ((filename arrays-tuples-nested.stan) (line_num 19) (col_num 81)
        (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (STuple
-        (SReal
-         (SArray
+        ((SReal AoS)
+         (SArray AoS
           (STuple
-           (SReal
-            (SArray
+           ((SReal AoS)
+            (SArray AoS
              (STuple
               (SComplex
                (SMatrix AoS
@@ -9733,13 +9733,13 @@
           ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (STuple
-        (SReal
-         (SArray
+        ((SReal AoS)
+         (SArray AoS
           (STuple
-           (SReal
-            (SArray
+           ((SReal AoS)
+            (SArray AoS
              (STuple
               (SComplex
                (SMatrix AoS
@@ -9761,7 +9761,7 @@
 ((functions_block ()) (input_vars ()) (prepare_data ())
  (log_prob
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id x) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id x) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -9779,7 +9779,7 @@
          (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id z)
           (decl_type
            (Sized
-            (SArray (STuple (SReal SReal))
+            (SArray AoS (STuple ((SReal AoS) (SReal AoS)))
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
           (initialize true)))
@@ -9829,7 +9829,7 @@
     (meta <opaque>))))
  (reverse_mode_log_prob
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id x) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id x) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -9847,7 +9847,7 @@
          (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id z)
           (decl_type
            (Sized
-            (SArray (STuple (SReal SReal))
+            (SArray SoA (STuple ((SReal AoS) (SReal AoS)))
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
           (initialize true)))
@@ -9897,7 +9897,7 @@
     (meta <opaque>))))
  (generate_quantities
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id x) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id x) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -9942,7 +9942,7 @@
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id x) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id x) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -9969,7 +9969,7 @@
     (meta <opaque>))))
  (unconstrain_array
   (((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id x) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id x) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -9991,14 +9991,14 @@
       ((filename infer_tuple_ad.stan) (line_num 2) (col_num 2) (included_from ())))
      (end_loc
       ((filename infer_tuple_ad.stan) (line_num 2) (col_num 9) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
-     (out_trans Identity)))))
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters) (out_trans Identity)))))
  (prog_name infer_tuple_ad_model) (prog_path infer_tuple_ad.stan))
   $ ../../../../../install/default/bin/stanc -fsoa --debug-optimized-mir simple.stan
 ((functions_block ()) (input_vars ())
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -10007,7 +10007,7 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id x)
-      (decl_type (Sized (STuple (SReal SInt)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SInt AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable x) ()) (UTuple (UReal UInt))
@@ -10062,7 +10062,7 @@
 ((functions_block ()) (input_vars ())
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -10074,10 +10074,10 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SInt))))
+          (SInt AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -10144,7 +10144,7 @@
 ((functions_block ()) (input_vars ())
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -10156,13 +10156,13 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray
-           (SArray SReal
+         ((SArray AoS
+           (SArray AoS (SReal AoS)
             ((pattern (Lit Int 3))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SInt))))
+          (SInt AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -10252,7 +10252,7 @@
      (end_loc
       ((filename tuple-constraints-data.stan) (line_num 2) (col_num 60)
        (included_from ()))))
-    (STuple (SInt (STuple (SReal SInt)))))
+    (STuple ((SInt AoS) (STuple ((SReal AoS) (SInt AoS))))))
    (x
     ((begin_loc
       ((filename tuple-constraints-data.stan) (line_num 3) (col_num 2)
@@ -10261,7 +10261,7 @@
       ((filename tuple-constraints-data.stan) (line_num 3) (col_num 51)
        (included_from ()))))
     (STuple
-     (SInt SReal
+     ((SInt AoS) (SReal AoS)
       (SVector AoS
        ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
    (z
@@ -10271,17 +10271,17 @@
      (end_loc
       ((filename tuple-constraints-data.stan) (line_num 4) (col_num 48)
        (included_from ()))))
-    (SArray
-     (SArray
+    (SArray AoS
+     (SArray AoS
       (STuple
-       (SReal
+       ((SReal AoS)
         (SVector AoS
          ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
      ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -10290,7 +10290,8 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype (TupleAD (DataOnly (TupleAD (DataOnly DataOnly))))) 
-      (decl_id y) (decl_type (Sized (STuple (SInt (STuple (SReal SInt))))))
+      (decl_id y)
+      (decl_type (Sized (STuple ((SInt AoS) (STuple ((SReal AoS) (SInt AoS)))))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -10417,7 +10418,7 @@
       (decl_type
        (Sized
         (STuple
-         (SInt SReal
+         ((SInt AoS) (SReal AoS)
           (SVector AoS
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))
@@ -10571,10 +10572,10 @@
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id z)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 4))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -10629,8 +10630,8 @@
           ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
         (meta <opaque>))
        ((pattern
-         (Decl (decl_adtype DataOnly) (decl_id z_dot_1_temp__) (decl_type (Sized SReal))
-          (initialize true)))
+         (Decl (decl_adtype DataOnly) (decl_id z_dot_1_temp__)
+          (decl_type (Sized (SReal AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id z_dot_2_temp__)
@@ -10983,10 +10984,10 @@
      (end_loc
       ((filename tuple-constraints-params.stan) (line_num 7) (col_num 34)
        (included_from ()))))
-    SInt)))
+    (SInt AoS))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id indicator) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id indicator) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -11031,7 +11032,7 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype DataOnly) (decl_id complicated_brack_dot2_1dim__)
-      (decl_type (Sized SInt)) (initialize true)))
+      (decl_type (Sized (SInt AoS))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable complicated_brack_dot2_1dim__) ()) UInt
@@ -11064,7 +11065,7 @@
  (log_prob
   (((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -11098,10 +11099,10 @@
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps2)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 4))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -11183,7 +11184,7 @@
         (meta <opaque>)))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id t) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id t) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -11221,12 +11222,12 @@
       (decl_id complicated)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
+             ((SReal AoS)
               (SVector AoS
                ((pattern (Lit Int 5))
                 (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11360,7 +11361,7 @@
  (reverse_mode_log_prob
   (((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -11394,10 +11395,10 @@
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps2)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 4))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -11479,7 +11480,7 @@
         (meta <opaque>)))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id t) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id t) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -11517,12 +11518,12 @@
       (decl_id complicated)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
+             ((SReal AoS)
               (SVector AoS
                ((pattern (Lit Int 5))
                 (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -11656,7 +11657,7 @@
  (generate_quantities
   (((pattern
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -11690,10 +11691,10 @@
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id ps2)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 4))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -11775,7 +11776,7 @@
         (meta <opaque>)))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id t) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id t) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -11811,12 +11812,12 @@
       (decl_id complicated)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
+             ((SReal AoS)
               (SVector AoS
                ((pattern (Lit Int 5))
                 (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -12263,7 +12264,7 @@
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -12272,7 +12273,7 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -12340,10 +12341,10 @@
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps2)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 4))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -12399,7 +12400,7 @@
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id ps2_dot_1_temp__)
-          (decl_type (Sized SReal)) (initialize true)))
+          (decl_type (Sized (SReal AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id ps2_dot_2_temp__)
@@ -12674,7 +12675,7 @@
         (meta <opaque>)))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id t) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id t) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -12724,12 +12725,12 @@
       (decl_id complicated)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
+             ((SReal AoS)
               (SVector AoS
                ((pattern (Lit Int 5))
                 (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -12842,16 +12843,16 @@
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype DataOnly) (decl_id complicated_dot_1_temp__)
-          (decl_type (Sized SReal)) (initialize true)))
+          (decl_type (Sized (SReal AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype (TupleAD (DataOnly DataOnly DataOnly)))
           (decl_id complicated_dot_2_temp__)
           (decl_type
            (Sized
-            (SArray
+            (SArray AoS
              (STuple
-              (SReal
+              ((SReal AoS)
                (SVector AoS
                 ((pattern (Lit Int 5))
                  (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -12900,8 +12901,8 @@
                  (Block
                   (((pattern
                      (Decl (decl_adtype DataOnly)
-                      (decl_id complicated_dot_2_dot_1_temp__) (decl_type (Sized SReal))
-                      (initialize true)))
+                      (decl_id complicated_dot_2_dot_1_temp__)
+                      (decl_type (Sized (SReal AoS))) (initialize true)))
                     (meta <opaque>))
                    ((pattern
                      (Decl (decl_adtype DataOnly)
@@ -13505,7 +13506,7 @@
  (unconstrain_array
   (((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -13555,10 +13556,10 @@
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps2)
       (decl_type
        (Sized
-        (SArray
-         (SArray
+        (SArray AoS
+         (SArray AoS
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 4))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -13706,7 +13707,7 @@
         (meta <opaque>)))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id t) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id t) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -13747,12 +13748,12 @@
       (decl_id complicated)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray
+          ((SReal AoS)
+           (SArray AoS
             (STuple
-             (SReal
+             ((SReal AoS)
               (SVector AoS
                ((pattern (Lit Int 5))
                 (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -14054,8 +14055,8 @@
      (end_loc
       ((filename tuple-constraints-params.stan) (line_num 10) (col_num 41)
        (included_from ()))))
-    ((out_unconstrained_st (STuple (SReal SReal)))
-     (out_constrained_st (STuple (SReal SReal))) (out_block Parameters)
+    ((out_unconstrained_st (STuple ((SReal AoS) (SReal AoS))))
+     (out_constrained_st (STuple ((SReal AoS) (SReal AoS)))) (out_block Parameters)
      (out_trans
       (TupleTransformation
        ((Lower
@@ -14070,10 +14071,10 @@
       ((filename tuple-constraints-params.stan) (line_num 11) (col_num 51)
        (included_from ()))))
     ((out_unconstrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (STuple
-         (SReal
+         ((SReal AoS)
           (SVector AoS
            ((pattern
              (FunApp (StanLib Minus__ FnPlain AoS)
@@ -14085,10 +14086,10 @@
         ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
-       (SArray
+      (SArray AoS
+       (SArray AoS
         (STuple
-         (SReal
+         ((SReal AoS)
           (SVector AoS
            ((pattern (Lit Int 4))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -14107,7 +14108,8 @@
      (end_loc
       ((filename tuple-constraints-params.stan) (line_num 12) (col_num 36)
        (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal) (out_block Parameters)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
+     (out_block Parameters)
      (out_trans
       (LowerUpper
        ((pattern
@@ -14134,12 +14136,12 @@
       ((filename tuple-constraints-params.stan) (line_num 15) (col_num 81)
        (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (STuple
-        (SReal
-         (SArray
+        ((SReal AoS)
+         (SArray AoS
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern
                (FunApp (StanLib Minus__ FnPlain AoS)
@@ -14190,12 +14192,12 @@
            (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
        ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (STuple
-        (SReal
-         (SArray
+        ((SReal AoS)
+         (SArray AoS
           (STuple
-           (SReal
+           ((SReal AoS)
             (SVector AoS
              ((pattern (Lit Int 5))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -14242,10 +14244,10 @@
       ((filename tuple-dataonly.stan) (line_num 7) (col_num 2) (included_from ())))
      (end_loc
       ((filename tuple-dataonly.stan) (line_num 7) (col_num 22) (included_from ()))))
-    (STuple (SReal SReal)))))
+    (STuple ((SReal AoS) (SReal AoS))))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -14254,7 +14256,7 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id d)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable d) ()) 1) ()) UReal
@@ -14342,7 +14344,7 @@
 ((functions_block ()) (input_vars ())
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -14353,7 +14355,7 @@
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id arr)
       (decl_type
        (Sized
-        (SArray (STuple (SReal SReal))
+        (SArray AoS (STuple ((SReal AoS) (SReal AoS)))
          ((pattern (Lit Int 100))
           (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -14431,15 +14433,15 @@
     ((begin_loc ((filename tuple-full.stan) (line_num 2) (col_num 2) (included_from ())))
      (end_loc ((filename tuple-full.stan) (line_num 2) (col_num 69) (included_from ()))))
     (STuple
-     (SInt
+     ((SInt AoS)
       (STuple
-       ((SArray SInt
+       ((SArray AoS (SInt AoS)
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -14452,12 +14454,12 @@
       (decl_type
        (Sized
         (STuple
-         (SInt
+         ((SInt AoS)
           (STuple
-           ((SArray SInt
+           ((SArray AoS (SInt AoS)
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-            (SArray SInt
+            (SArray AoS (SInt AoS)
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))))
       (initialize true)))
@@ -14541,7 +14543,7 @@
  (log_prob
   (((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -14670,7 +14672,7 @@
  (reverse_mode_log_prob
   (((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -14799,7 +14801,7 @@
  (generate_quantities
   (((pattern
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -14880,7 +14882,7 @@
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -14889,7 +14891,7 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -14956,7 +14958,7 @@
  (unconstrain_array
   (((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -15006,8 +15008,8 @@
   ((ps
     ((begin_loc ((filename tuple-full.stan) (line_num 5) (col_num 2) (included_from ())))
      (end_loc ((filename tuple-full.stan) (line_num 5) (col_num 41) (included_from ()))))
-    ((out_unconstrained_st (STuple (SReal SReal)))
-     (out_constrained_st (STuple (SReal SReal))) (out_block Parameters)
+    ((out_unconstrained_st (STuple ((SReal AoS) (SReal AoS))))
+     (out_constrained_st (STuple ((SReal AoS) (SReal AoS)))) (out_block Parameters)
      (out_trans
       (TupleTransformation
        ((Lower
@@ -15019,7 +15021,7 @@
 ((functions_block ()) (input_vars ())
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -15028,7 +15030,7 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id x)
-      (decl_type (Sized (STuple (SInt SInt)))) (initialize true)))
+      (decl_type (Sized (STuple ((SInt AoS) (SInt AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable x) ()) 1) ()) UInt
@@ -15065,7 +15067,7 @@
 ((functions_block ()) (input_vars ())
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -15077,10 +15079,10 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SInt
+         ((SArray AoS (SInt AoS)
            ((pattern (Lit Int 10))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SInt))))
+          (SInt AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -15122,7 +15124,7 @@
 ((functions_block ()) (input_vars ())
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -15133,7 +15135,7 @@
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id x)
       (decl_type
        (Sized
-        (SArray (STuple (SInt SInt))
+        (SArray AoS (STuple ((SInt AoS) (SInt AoS)))
          ((pattern (Lit Int 10)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -15180,7 +15182,7 @@
 ((functions_block ()) (input_vars ())
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -15193,15 +15195,15 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray
+         ((SArray AoS
            (STuple
-            (SInt
-             (SArray SReal
+            ((SInt AoS)
+             (SArray AoS (SReal AoS)
               ((pattern (Lit Int 100))
                (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
            ((pattern (Lit Int 10))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SInt))))
+          (SInt AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -15248,7 +15250,7 @@
  (log_prob
   (((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -15274,9 +15276,9 @@
       (decl_type
        (Sized
         (STuple
-         (SReal
+         ((SReal AoS)
           (STuple
-           (SReal
+           ((SReal AoS)
             (SMatrix AoS
              ((pattern (Lit Int 10))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -15322,7 +15324,7 @@
  (reverse_mode_log_prob
   (((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -15348,9 +15350,9 @@
       (decl_type
        (Sized
         (STuple
-         (SReal
+         ((SReal AoS)
           (STuple
-           (SReal
+           ((SReal AoS)
             (SMatrix AoS
              ((pattern (Lit Int 10))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -15396,7 +15398,7 @@
  (generate_quantities
   (((pattern
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -15422,9 +15424,9 @@
       (decl_type
        (Sized
         (STuple
-         (SReal
+         ((SReal AoS)
           (STuple
-           (SReal
+           ((SReal AoS)
             (SMatrix AoS
              ((pattern (Lit Int 10))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -15571,7 +15573,7 @@
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -15580,7 +15582,7 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -15642,9 +15644,9 @@
       (decl_type
        (Sized
         (STuple
-         (SReal
+         ((SReal AoS)
           (STuple
-           (SReal
+           ((SReal AoS)
             (SMatrix AoS
              ((pattern (Lit Int 10))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -15813,7 +15815,7 @@
  (unconstrain_array
   (((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -15857,9 +15859,9 @@
       (decl_type
        (Sized
         (STuple
-         (SReal
+         ((SReal AoS)
           (STuple
-           (SReal
+           ((SReal AoS)
             (SMatrix AoS
              ((pattern (Lit Int 10))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -15948,8 +15950,8 @@
       ((filename tuple-nested-param.stan) (line_num 2) (col_num 2) (included_from ())))
      (end_loc
       ((filename tuple-nested-param.stan) (line_num 2) (col_num 23) (included_from ()))))
-    ((out_unconstrained_st (STuple (SReal SReal)))
-     (out_constrained_st (STuple (SReal SReal))) (out_block Parameters)
+    ((out_unconstrained_st (STuple ((SReal AoS) (SReal AoS))))
+     (out_constrained_st (STuple ((SReal AoS) (SReal AoS)))) (out_block Parameters)
      (out_trans (TupleTransformation (Identity Identity)))))
    (ps2
     ((begin_loc
@@ -15958,9 +15960,9 @@
       ((filename tuple-nested-param.stan) (line_num 3) (col_num 47) (included_from ()))))
     ((out_unconstrained_st
       (STuple
-       (SReal
+       ((SReal AoS)
         (STuple
-         (SReal
+         ((SReal AoS)
           (SMatrix AoS
            ((pattern (Lit Int 10))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -15968,9 +15970,9 @@
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))))
      (out_constrained_st
       (STuple
-       (SReal
+       ((SReal AoS)
         (STuple
-         (SReal
+         ((SReal AoS)
           (SMatrix AoS
            ((pattern (Lit Int 10))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -15985,7 +15987,7 @@
  (log_prob
   (((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -16013,7 +16015,7 @@
  (reverse_mode_log_prob
   (((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -16041,7 +16043,7 @@
  (generate_quantities
   (((pattern
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -16117,7 +16119,7 @@
     (meta <opaque>))))
  (transform_inits
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16126,7 +16128,7 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -16189,7 +16191,7 @@
  (unconstrain_array
   (((pattern
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id ps)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LTupleProjection ((LVariable ps) ()) 1) ()) UReal
@@ -16237,8 +16239,8 @@
       ((filename tuple-params.stan) (line_num 2) (col_num 2) (included_from ())))
      (end_loc
       ((filename tuple-params.stan) (line_num 2) (col_num 32) (included_from ()))))
-    ((out_unconstrained_st (STuple (SReal SReal)))
-     (out_constrained_st (STuple (SReal SReal))) (out_block Parameters)
+    ((out_unconstrained_st (STuple ((SReal AoS) (SReal AoS))))
+     (out_constrained_st (STuple ((SReal AoS) (SReal AoS)))) (out_block Parameters)
      (out_trans
       (TupleTransformation
        (Identity
@@ -16300,13 +16302,13 @@
      (end_loc
       ((filename tuple-promotion.stan) (line_num 8) (col_num 38) (included_from ()))))
     (STuple
-     ((SArray SInt
+     ((SArray AoS (SInt AoS)
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-      (SArray SInt
+      (SArray AoS (SInt AoS)
        ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16384,10 +16386,10 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SInt
+         ((SArray AoS (SInt AoS)
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          (SArray SInt
+          (SArray AoS (SInt AoS)
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))
       (initialize true)))
@@ -16412,10 +16414,10 @@
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id arrs)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SInt
-           (SArray SInt
+          ((SInt AoS)
+           (SArray AoS (SInt AoS)
             ((pattern (Lit Int 2))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
          ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -16430,16 +16432,16 @@
        (Sized
         (STuple
          ((STuple
-           (SInt
-            (SArray SInt
+           ((SInt AoS)
+            (SArray AoS (SInt AoS)
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
-          SInt
+          (SInt AoS)
           (STuple
            ((SVector AoS
              ((pattern (Lit Int 3))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-            SInt))))))
+            (SInt AoS)))))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16447,7 +16449,7 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SReal
+         ((SArray AoS (SReal AoS)
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
           SComplex))))
@@ -16490,7 +16492,7 @@
          ((SComplexVector
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal))))
+          (SReal AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16521,7 +16523,7 @@
          ((SVector AoS
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SInt))))
+          (SInt AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16548,7 +16550,7 @@
          (adlevel (TupleAD (DataOnly DataOnly))))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id t) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id t) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16573,10 +16575,10 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SComplex
+         ((SArray AoS SComplex
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          (SArray SComplex
+          (SArray AoS SComplex
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))
       (initialize true)))
@@ -16602,7 +16604,7 @@
          ((SVector AoS
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal))))
+          (SReal AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16622,10 +16624,10 @@
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id arrs2)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray SComplex
+          ((SReal AoS)
+           (SArray AoS SComplex
             ((pattern (Lit Int 2))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
          ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -16655,16 +16657,16 @@
        (Sized
         (STuple
          ((STuple
-           (SReal
-            (SArray SComplex
+           ((SReal AoS)
+            (SArray AoS SComplex
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
-          SReal
+          (SReal AoS)
           (STuple
            ((SVector AoS
              ((pattern (Lit Int 3))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-            SReal))))))
+            (SReal AoS)))))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16704,16 +16706,16 @@
        (Sized
         (STuple
          ((STuple
-           (SReal
-            (SArray SComplex
+           ((SReal AoS)
+            (SArray AoS SComplex
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
-          SReal
+          (SReal AoS)
           (STuple
            ((SVector AoS
              ((pattern (Lit Int 3))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-            SReal))))))
+            (SReal AoS)))))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16748,10 +16750,10 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SComplex
+         ((SArray AoS SComplex
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          (SArray SComplex
+          (SArray AoS SComplex
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))
       (initialize true)))
@@ -16777,7 +16779,7 @@
          ((SVector AoS
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal))))
+          (SReal AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16797,10 +16799,10 @@
      (Decl (decl_adtype (TupleAD (AutoDiffable AutoDiffable))) (decl_id arrs2)
       (decl_type
        (Sized
-        (SArray
+        (SArray SoA
          (STuple
-          (SReal
-           (SArray SComplex
+          ((SReal AoS)
+           (SArray AoS SComplex
             ((pattern (Lit Int 2))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
          ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -16830,16 +16832,16 @@
        (Sized
         (STuple
          ((STuple
-           (SReal
-            (SArray SComplex
+           ((SReal AoS)
+            (SArray AoS SComplex
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
-          SReal
+          (SReal AoS)
           (STuple
            ((SVector AoS
              ((pattern (Lit Int 3))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-            SReal))))))
+            (SReal AoS)))))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16879,16 +16881,16 @@
        (Sized
         (STuple
          ((STuple
-           (SReal
-            (SArray SComplex
+           ((SReal AoS)
+            (SArray AoS SComplex
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
-          SReal
+          (SReal AoS)
           (STuple
            ((SVector AoS
              ((pattern (Lit Int 3))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-            SReal))))))
+            (SReal AoS)))))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16923,10 +16925,10 @@
       (decl_type
        (Sized
         (STuple
-         ((SArray SComplex
+         ((SArray AoS SComplex
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          (SArray SComplex
+          (SArray AoS SComplex
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))
       (initialize true)))
@@ -16939,17 +16941,17 @@
          ((SVector AoS
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal))))
+          (SReal AoS)))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id arrs2)
       (decl_type
        (Sized
-        (SArray
+        (SArray AoS
          (STuple
-          (SReal
-           (SArray SComplex
+          ((SReal AoS)
+           (SArray AoS SComplex
             ((pattern (Lit Int 2))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
          ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
@@ -16964,16 +16966,16 @@
        (Sized
         (STuple
          ((STuple
-           (SReal
-            (SArray SComplex
+           ((SReal AoS)
+            (SArray AoS SComplex
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
-          SReal
+          (SReal AoS)
           (STuple
            ((SVector AoS
              ((pattern (Lit Int 3))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-            SReal))))))
+            (SReal AoS)))))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -16985,16 +16987,16 @@
        (Sized
         (STuple
          ((STuple
-           (SReal
-            (SArray SComplex
+           ((SReal AoS)
+            (SArray AoS SComplex
              ((pattern (Lit Int 2))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
-          SReal
+          (SReal AoS)
           (STuple
            ((SVector AoS
              ((pattern (Lit Int 3))
               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-            SReal))))))
+            (SReal AoS)))))))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -17572,7 +17574,8 @@
       ((pattern (Block (((pattern (Return ())) (meta <opaque>))))) (meta <opaque>)) ()))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id y) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id y) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable y) ()) UInt
@@ -17580,7 +17583,7 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id x)
-      (decl_type (Sized (STuple (SReal SReal)))) (initialize true)))
+      (decl_type (Sized (STuple ((SReal AoS) (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable x) ()) (UTuple (UReal UReal))
@@ -17603,7 +17606,7 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id z)
-      (decl_type (Sized (STuple (SComplex SReal)))) (initialize true)))
+      (decl_type (Sized (STuple (SComplex (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable z) ()) (UTuple (UComplex UReal))
@@ -17620,7 +17623,7 @@
     (meta <opaque>))
    ((pattern
      (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id z2)
-      (decl_type (Sized (STuple (SComplex SReal)))) (initialize true)))
+      (decl_type (Sized (STuple (SComplex (SReal AoS))))) (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable z2) ()) (UTuple (UComplex UReal))
@@ -17723,15 +17726,15 @@
       ((filename tuple-promotion.stan) (line_num 24) (col_num 51) (included_from ()))))
     ((out_unconstrained_st
       (STuple
-       ((SArray SComplex
+       ((SArray AoS SComplex
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-        (SArray SComplex
+        (SArray AoS SComplex
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
      (out_constrained_st
       (STuple
-       ((SArray SComplex
+       ((SArray AoS SComplex
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-        (SArray SComplex
+        (SArray AoS SComplex
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
      (out_block TransformedParameters)
      (out_trans (TupleTransformation (Identity Identity)))))
@@ -17744,12 +17747,12 @@
       (STuple
        ((SVector AoS
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-        SReal)))
+        (SReal AoS))))
      (out_constrained_st
       (STuple
        ((SVector AoS
          ((pattern (Lit Int 3)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-        SReal)))
+        (SReal AoS))))
      (out_block TransformedParameters)
      (out_trans (TupleTransformation (Identity Identity)))))
    (arrs2
@@ -17758,17 +17761,17 @@
      (end_loc
       ((filename tuple-promotion.stan) (line_num 27) (col_num 54) (included_from ()))))
     ((out_unconstrained_st
-      (SArray
+      (SArray AoS
        (STuple
-        (SReal
-         (SArray SComplex
+        ((SReal AoS)
+         (SArray AoS SComplex
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
        ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray
+      (SArray AoS
        (STuple
-        (SReal
-         (SArray SComplex
+        ((SReal AoS)
+         (SArray AoS SComplex
           ((pattern (Lit Int 2)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
        ((pattern (Lit Int 4)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block TransformedParameters)
@@ -17781,29 +17784,29 @@
     ((out_unconstrained_st
       (STuple
        ((STuple
-         (SReal
-          (SArray SComplex
+         ((SReal AoS)
+          (SArray AoS SComplex
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
-        SReal
+        (SReal AoS)
         (STuple
          ((SVector AoS
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal)))))
+          (SReal AoS))))))
      (out_constrained_st
       (STuple
        ((STuple
-         (SReal
-          (SArray SComplex
+         ((SReal AoS)
+          (SArray AoS SComplex
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
-        SReal
+        (SReal AoS)
         (STuple
          ((SVector AoS
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal)))))
+          (SReal AoS))))))
      (out_block TransformedParameters)
      (out_trans
       (TupleTransformation
@@ -17817,29 +17820,29 @@
     ((out_unconstrained_st
       (STuple
        ((STuple
-         (SReal
-          (SArray SComplex
+         ((SReal AoS)
+          (SArray AoS SComplex
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
-        SReal
+        (SReal AoS)
         (STuple
          ((SVector AoS
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal)))))
+          (SReal AoS))))))
      (out_constrained_st
       (STuple
        ((STuple
-         (SReal
-          (SArray SComplex
+         ((SReal AoS)
+          (SArray AoS SComplex
            ((pattern (Lit Int 2))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
-        SReal
+        (SReal AoS)
         (STuple
          ((SVector AoS
            ((pattern (Lit Int 3))
             (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
-          SReal)))))
+          (SReal AoS))))))
      (out_block TransformedParameters)
      (out_trans
       (TupleTransformation
@@ -17850,31 +17853,32 @@
       ((filename tuple-promotion.stan) (line_num 34) (col_num 2) (included_from ())))
      (end_loc
       ((filename tuple-promotion.stan) (line_num 34) (col_num 12) (included_from ()))))
-    ((out_unconstrained_st SInt) (out_constrained_st SInt)
+    ((out_unconstrained_st (SInt AoS)) (out_constrained_st (SInt AoS))
      (out_block GeneratedQuantities) (out_trans Identity)))
    (x
     ((begin_loc
       ((filename tuple-promotion.stan) (line_num 35) (col_num 2) (included_from ())))
      (end_loc
       ((filename tuple-promotion.stan) (line_num 35) (col_num 31) (included_from ()))))
-    ((out_unconstrained_st (STuple (SReal SReal)))
-     (out_constrained_st (STuple (SReal SReal))) (out_block GeneratedQuantities)
+    ((out_unconstrained_st (STuple ((SReal AoS) (SReal AoS))))
+     (out_constrained_st (STuple ((SReal AoS) (SReal AoS))))
+     (out_block GeneratedQuantities)
      (out_trans (TupleTransformation (Identity Identity)))))
    (z
     ((begin_loc
       ((filename tuple-promotion.stan) (line_num 36) (col_num 2) (included_from ())))
      (end_loc
       ((filename tuple-promotion.stan) (line_num 36) (col_num 29) (included_from ()))))
-    ((out_unconstrained_st (STuple (SComplex SReal)))
-     (out_constrained_st (STuple (SComplex SReal))) (out_block GeneratedQuantities)
+    ((out_unconstrained_st (STuple (SComplex (SReal AoS))))
+     (out_constrained_st (STuple (SComplex (SReal AoS)))) (out_block GeneratedQuantities)
      (out_trans (TupleTransformation (Identity Identity)))))
    (z2
     ((begin_loc
       ((filename tuple-promotion.stan) (line_num 37) (col_num 2) (included_from ())))
      (end_loc
       ((filename tuple-promotion.stan) (line_num 37) (col_num 30) (included_from ()))))
-    ((out_unconstrained_st (STuple (SComplex SReal)))
-     (out_constrained_st (STuple (SComplex SReal))) (out_block GeneratedQuantities)
+    ((out_unconstrained_st (STuple (SComplex (SReal AoS))))
+     (out_constrained_st (STuple (SComplex (SReal AoS)))) (out_block GeneratedQuantities)
      (out_trans (TupleTransformation (Identity Identity)))))))
  (prog_name tuple_promotion_model) (prog_path tuple-promotion.stan))
   $ ../../../../../install/default/bin/stanc -fsoa --debug-optimized-mir tuple-templating.stan
@@ -17997,7 +18001,7 @@
       ((filename tuple-templating.stan) (line_num 24) (col_num 2) (included_from ())))
      (end_loc
       ((filename tuple-templating.stan) (line_num 24) (col_num 8) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (m1
     ((begin_loc
       ((filename tuple-templating.stan) (line_num 25) (col_num 2) (included_from ())))
@@ -18019,18 +18023,18 @@
       ((filename tuple-templating.stan) (line_num 27) (col_num 2) (included_from ())))
      (end_loc
       ((filename tuple-templating.stan) (line_num 27) (col_num 18) (included_from ()))))
-    (SArray SInt
+    (SArray AoS (SInt AoS)
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (a2
     ((begin_loc
       ((filename tuple-templating.stan) (line_num 28) (col_num 2) (included_from ())))
      (end_loc
       ((filename tuple-templating.stan) (line_num 28) (col_num 19) (included_from ()))))
-    (SArray SReal
+    (SArray AoS (SReal AoS)
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -18038,7 +18042,8 @@
       ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable N) ()) UInt
@@ -18254,7 +18259,7 @@
      (Decl (decl_adtype DataOnly) (decl_id a1)
       (decl_type
        (Sized
-        (SArray SInt
+        (SArray AoS (SInt AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -18276,7 +18281,7 @@
      (Decl (decl_adtype DataOnly) (decl_id a2)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -18331,7 +18336,7 @@
           (adlevel (TupleAD (DataOnly DataOnly)))))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id s) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id s) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -18439,7 +18444,7 @@
       ((filename tuple-templating.stan) (line_num 34) (col_num 2) (included_from ())))
      (end_loc
       ((filename tuple-templating.stan) (line_num 34) (col_num 26) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
      (out_block GeneratedQuantities) (out_trans Identity)))))
  (prog_name tuple_templating_model) (prog_path tuple-templating.stan))
   $ ../../../../../install/default/bin/stanc -fsoa --debug-optimized-mir tuple_hof.stan
@@ -18477,22 +18482,22 @@
   ((N
     ((begin_loc ((filename tuple_hof.stan) (line_num 8) (col_num 2) (included_from ())))
      (end_loc ((filename tuple_hof.stan) (line_num 8) (col_num 8) (included_from ()))))
-    SInt)
+    (SInt AoS))
    (data_y
     ((begin_loc ((filename tuple_hof.stan) (line_num 9) (col_num 2) (included_from ())))
      (end_loc ((filename tuple_hof.stan) (line_num 9) (col_num 23) (included_from ()))))
-    (SArray SReal
+    (SArray AoS (SReal AoS)
      ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
    (data_m
     ((begin_loc ((filename tuple_hof.stan) (line_num 10) (col_num 2) (included_from ())))
      (end_loc ((filename tuple_hof.stan) (line_num 10) (col_num 35) (included_from ()))))
     (STuple
-     (SReal
-      (SArray SInt
+     ((SReal AoS)
+      (SArray AoS (SInt AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))))))
  (prepare_data
   (((pattern
-     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized SInt))
+     (Decl (decl_adtype DataOnly) (decl_id pos__) (decl_type (Sized (SInt AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -18500,7 +18505,8 @@
       ((pattern (Lit Int 1)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized SInt)) (initialize true)))
+     (Decl (decl_adtype DataOnly) (decl_id N) (decl_type (Sized (SInt AoS)))
+      (initialize true)))
     (meta <opaque>))
    ((pattern
      (Assignment ((LVariable N) ()) UInt
@@ -18527,7 +18533,7 @@
      (Decl (decl_adtype DataOnly) (decl_id data_y)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -18551,8 +18557,8 @@
       (decl_type
        (Sized
         (STuple
-         (SReal
-          (SArray SInt
+         ((SReal AoS)
+          (SArray AoS (SInt AoS)
            ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))))
       (initialize true)))
     (meta <opaque>))
@@ -18579,7 +18585,7 @@
        (meta ((type_ (UArray UInt)) (loc <opaque>) (adlevel DataOnly))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id sum1) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id sum1) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -18615,7 +18621,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id param_y)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -18632,7 +18638,7 @@
        (meta ((type_ (UArray UReal)) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sum2) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sum2) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -18661,7 +18667,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id param_y)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray SoA (SReal SoA)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -18678,7 +18684,7 @@
        (meta ((type_ (UArray UReal)) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype AutoDiffable) (decl_id sum2) (decl_type (Sized SReal))
+     (Decl (decl_adtype AutoDiffable) (decl_id sum2) (decl_type (Sized (SReal SoA)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -18707,7 +18713,7 @@
      (Decl (decl_adtype DataOnly) (decl_id param_y)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -18724,7 +18730,7 @@
        (meta ((type_ (UArray UReal)) (loc <opaque>) (adlevel AutoDiffable))))))
     (meta <opaque>))
    ((pattern
-     (Decl (decl_adtype DataOnly) (decl_id sum2) (decl_type (Sized SReal))
+     (Decl (decl_adtype DataOnly) (decl_id sum2) (decl_type (Sized (SReal AoS)))
       (initialize true)))
     (meta <opaque>))
    ((pattern
@@ -18803,7 +18809,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id param_y)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -18829,7 +18835,7 @@
      (Decl (decl_adtype AutoDiffable) (decl_id param_y)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
     (meta <opaque>))
@@ -18854,16 +18860,16 @@
     ((begin_loc ((filename tuple_hof.stan) (line_num 16) (col_num 2) (included_from ())))
      (end_loc ((filename tuple_hof.stan) (line_num 16) (col_num 24) (included_from ()))))
     ((out_unconstrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_constrained_st
-      (SArray SReal
+      (SArray AoS (SReal AoS)
        ((pattern (Var N)) (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
      (out_block Parameters) (out_trans Identity)))
    (sum2
     ((begin_loc ((filename tuple_hof.stan) (line_num 19) (col_num 2) (included_from ())))
      (end_loc ((filename tuple_hof.stan) (line_num 19) (col_num 50) (included_from ()))))
-    ((out_unconstrained_st SReal) (out_constrained_st SReal)
+    ((out_unconstrained_st (SReal AoS)) (out_constrained_st (SReal AoS))
      (out_block TransformedParameters) (out_trans Identity)))))
  (prog_name tuple_hof_model) (prog_path tuple_hof.stan))
   $ ../../../../../install/default/bin/stanc -fsoa --debug-optimized-mir tuple_lpdf.stan
diff --git a/test/integration/signatures/stan_math_distributions.t b/test/integration/signatures/stan_math_distributions.t
index 31e46c463..0615363ac 100644
--- a/test/integration/signatures/stan_math_distributions.t
+++ b/test/integration/signatures/stan_math_distributions.t
@@ -1,31 +1,41 @@
 Display all Stan math distributions exposed in the language
   $ stanc --dump-stan-math-distributions
-  beta_binomial: lpmf, rng, ccdf, cdf, log (deprecated)
-  beta: lpdf, rng, ccdf, cdf, log (deprecated)
-  beta_proportion: lpdf, ccdf, cdf, log (deprecated)
   bernoulli: lpmf, rng, ccdf, cdf, log (deprecated)
-  bernoulli_logit: lpmf, rng, log (deprecated)
   bernoulli_logit_glm: lpmf
-  binomial: lpmf, rng, ccdf, cdf, log (deprecated)
-  binomial_logit: lpmf, log (deprecated)
+  bernoulli_logit: lpmf
+  bernoulli_logit: rng, log (deprecated)
+  beta_binomial: rng, ccdf, cdf, log (deprecated)
+  beta_binomial: lpmf
+  beta: rng, ccdf, cdf, log (deprecated)
+  beta: lpdf
+  beta_proportion: rng, ccdf, cdf, log (deprecated)
+  beta_proportion: lpdf
+  binomial_logit: log (deprecated)
+  binomial_logit: lpmf
+  binomial: rng, ccdf, cdf, log (deprecated)
+  binomial: lpmf
   categorical: lpmf, log (deprecated)
   categorical_logit: lpmf, log (deprecated)
   categorical_logit_glm: lpmf
   cauchy: lpdf, rng, ccdf, cdf, log (deprecated)
-  chi_square: lpdf, rng, ccdf, cdf, log (deprecated)
+  chi_square: rng, ccdf, cdf, log (deprecated)
+  chi_square: lpdf
   dirichlet: lpdf, log (deprecated)
   discrete_range: lpmf, rng, ccdf, cdf, log (deprecated)
   double_exponential: lpdf, rng, ccdf, cdf, log (deprecated)
   exp_mod_normal: lpdf, rng, ccdf, cdf, log (deprecated)
   exponential: lpdf, rng, ccdf, cdf, log (deprecated)
   frechet: lpdf, rng, ccdf, cdf, log (deprecated)
-  gamma: lpdf, rng, ccdf, cdf, log (deprecated)
+  gamma: rng, ccdf, cdf, log (deprecated)
+  gamma: lpdf
   gaussian_dlm_obs: lpdf, log (deprecated)
   gumbel: lpdf, rng, ccdf, cdf, log (deprecated)
   hmm_latent: rng
   hypergeometric: lpmf, rng, log (deprecated)
-  inv_chi_square: lpdf, rng, ccdf, cdf, log (deprecated)
-  inv_gamma: lpdf, rng, ccdf, cdf, log (deprecated)
+  inv_chi_square: rng, ccdf, cdf, log (deprecated)
+  inv_chi_square: lpdf
+  inv_gamma: rng, ccdf, cdf, log (deprecated)
+  inv_gamma: lpdf
   inv_wishart_cholesky: lpdf
   inv_wishart: lpdf, log (deprecated)
   lkj_corr: lpdf, log (deprecated)
@@ -43,8 +53,10 @@ Display all Stan math distributions exposed in the language
   multi_normal_prec: lpdf, log (deprecated)
   multi_student_t: lpdf, log (deprecated)
   multi_student_t_cholesky: lpdf
-  neg_binomial: lpmf, rng, ccdf, cdf, log (deprecated)
-  neg_binomial_2: lpmf, rng, ccdf, cdf, log (deprecated)
+  neg_binomial: rng, ccdf, cdf, log (deprecated)
+  neg_binomial: lpmf
+  neg_binomial_2: rng, ccdf, cdf, log (deprecated)
+  neg_binomial_2: lpmf
   neg_binomial_2_log: lpmf, rng, log (deprecated)
   neg_binomial_2_log_glm: lpmf
   normal: lpdf, rng, ccdf, cdf, log (deprecated)
@@ -54,15 +66,19 @@ Display all Stan math distributions exposed in the language
   ordered_probit: lpmf, log (deprecated)
   pareto: lpdf, rng, ccdf, cdf, log (deprecated)
   pareto_type_2: lpdf, rng, ccdf, cdf, log (deprecated)
-  poisson: lpmf, rng, ccdf, cdf, log (deprecated)
-  poisson_log: lpmf, rng, log (deprecated)
   poisson_log_glm: lpmf
+  poisson_log: lpmf, rng, log (deprecated)
+  poisson: rng, ccdf, cdf, log (deprecated)
+  poisson: lpmf
   rayleigh: lpdf, rng, ccdf, cdf, log (deprecated)
-  scaled_inv_chi_square: lpdf, rng, ccdf, cdf, log (deprecated)
-  skew_normal: lpdf, rng, ccdf, cdf, log (deprecated)
+  scaled_inv_chi_square: rng, ccdf, cdf, log (deprecated)
+  scaled_inv_chi_square: lpdf
   skew_double_exponential: lpdf, rng, ccdf, cdf, log (deprecated)
-  student_t: lpdf, rng, ccdf, cdf, log (deprecated)
+  skew_normal: rng, ccdf, cdf, log (deprecated)
+  skew_normal: lpdf
   std_normal: lpdf, rng, ccdf, cdf, log (deprecated)
+  student_t: rng, ccdf, cdf, log (deprecated)
+  student_t: lpdf
   uniform: lpdf, rng, ccdf, cdf, log (deprecated)
   von_mises: lpdf, rng, ccdf, cdf, log (deprecated)
   weibull: lpdf, rng, ccdf, cdf, log (deprecated)
diff --git a/test/integration/signatures/stan_math_signatures.t b/test/integration/signatures/stan_math_signatures.t
index e4b6231a2..e6afae189 100644
--- a/test/integration/signatures/stan_math_signatures.t
+++ b/test/integration/signatures/stan_math_signatures.t
@@ -2506,30 +2506,66 @@ Display all Stan math signatures exposed in the language
   beta_proportion_lpdf(array[] real, array[] real, row_vector) => real
   beta_proportion_lpdf(array[] real, array[] real, array[] int) => real
   beta_proportion_lpdf(array[] real, array[] real, array[] real) => real
+  beta_proportion_rng(int, int) => real
+  beta_proportion_rng(int, real) => real
   beta_proportion_rng(real, int) => real
+  beta_proportion_rng(real, int) => real
+  beta_proportion_rng(real, real) => real
   beta_proportion_rng(real, real) => real
+  beta_proportion_rng(int, vector) => array[] real
+  beta_proportion_rng(int, row_vector) => array[] real
+  beta_proportion_rng(int, array[] int) => array[] real
+  beta_proportion_rng(int, array[] real) => array[] real
+  beta_proportion_rng(real, vector) => array[] real
   beta_proportion_rng(real, vector) => array[] real
   beta_proportion_rng(real, row_vector) => array[] real
+  beta_proportion_rng(real, row_vector) => array[] real
+  beta_proportion_rng(real, array[] int) => array[] real
   beta_proportion_rng(real, array[] int) => array[] real
   beta_proportion_rng(real, array[] real) => array[] real
+  beta_proportion_rng(real, array[] real) => array[] real
   beta_proportion_rng(vector, int) => array[] real
+  beta_proportion_rng(vector, int) => array[] real
+  beta_proportion_rng(vector, real) => array[] real
   beta_proportion_rng(vector, real) => array[] real
   beta_proportion_rng(vector, vector) => array[] real
+  beta_proportion_rng(vector, vector) => array[] real
   beta_proportion_rng(vector, row_vector) => array[] real
+  beta_proportion_rng(vector, row_vector) => array[] real
+  beta_proportion_rng(vector, array[] int) => array[] real
   beta_proportion_rng(vector, array[] int) => array[] real
   beta_proportion_rng(vector, array[] real) => array[] real
+  beta_proportion_rng(vector, array[] real) => array[] real
   beta_proportion_rng(row_vector, int) => array[] real
+  beta_proportion_rng(row_vector, int) => array[] real
+  beta_proportion_rng(row_vector, real) => array[] real
   beta_proportion_rng(row_vector, real) => array[] real
   beta_proportion_rng(row_vector, vector) => array[] real
+  beta_proportion_rng(row_vector, vector) => array[] real
   beta_proportion_rng(row_vector, row_vector) => array[] real
+  beta_proportion_rng(row_vector, row_vector) => array[] real
+  beta_proportion_rng(row_vector, array[] int) => array[] real
   beta_proportion_rng(row_vector, array[] int) => array[] real
   beta_proportion_rng(row_vector, array[] real) => array[] real
+  beta_proportion_rng(row_vector, array[] real) => array[] real
+  beta_proportion_rng(array[] int, int) => array[] real
+  beta_proportion_rng(array[] int, real) => array[] real
+  beta_proportion_rng(array[] int, vector) => array[] real
+  beta_proportion_rng(array[] int, row_vector) => array[] real
+  beta_proportion_rng(array[] int, array[] int) => array[] real
+  beta_proportion_rng(array[] int, array[] real) => array[] real
   beta_proportion_rng(array[] real, int) => array[] real
+  beta_proportion_rng(array[] real, int) => array[] real
+  beta_proportion_rng(array[] real, real) => array[] real
   beta_proportion_rng(array[] real, real) => array[] real
   beta_proportion_rng(array[] real, vector) => array[] real
+  beta_proportion_rng(array[] real, vector) => array[] real
   beta_proportion_rng(array[] real, row_vector) => array[] real
+  beta_proportion_rng(array[] real, row_vector) => array[] real
+  beta_proportion_rng(array[] real, array[] int) => array[] real
   beta_proportion_rng(array[] real, array[] int) => array[] real
   beta_proportion_rng(array[] real, array[] real) => array[] real
+  beta_proportion_rng(array[] real, array[] real) => array[] real
   beta_rng(int, int) => real
   beta_rng(int, real) => real
   beta_rng(real, int) => real
diff --git a/test/unit/Ast_to_Mir_tests.ml b/test/unit/Ast_to_Mir_tests.ml
index d976549f5..c8d015112 100644
--- a/test/unit/Ast_to_Mir_tests.ml
+++ b/test/unit/Ast_to_Mir_tests.ml
@@ -40,8 +40,8 @@ let%expect_test "Prefix-Op-Example" =
       (((pattern
          (Block
           (((pattern
-             (Decl (decl_adtype AutoDiffable) (decl_id i) (decl_type (Sized SInt))
-              (initialize true)))
+             (Decl (decl_adtype AutoDiffable) (decl_id i)
+              (decl_type (Sized (SInt AoS))) (initialize true)))
             (meta <opaque>))
            ((pattern
              (IfElse
@@ -73,7 +73,7 @@ let%expect_test "read data" =
        (Decl (decl_adtype DataOnly) (decl_id mat)
         (decl_type
          (Sized
-          (SArray
+          (SArray AoS
            (SMatrix AoS
             ((pattern (Lit Int 10))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -95,7 +95,7 @@ let%expect_test "read param" =
        (Decl (decl_adtype AutoDiffable) (decl_id mat)
         (decl_type
          (Sized
-          (SArray
+          (SArray AoS
            (SMatrix AoS
             ((pattern (Lit Int 10))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -140,7 +140,7 @@ let%expect_test "gen quant" =
        (Decl (decl_adtype DataOnly) (decl_id mat)
         (decl_type
          (Sized
-          (SArray
+          (SArray AoS
            (SMatrix AoS
             ((pattern (Lit Int 10))
              (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))
@@ -175,7 +175,7 @@ let%expect_test "read data - constraint " =
      (Decl (decl_adtype DataOnly) (decl_id y)
       (decl_type
        (Sized
-        (SArray SReal
+        (SArray AoS (SReal AoS)
          ((pattern (Lit Int 5))
           (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
       (initialize true)))
@@ -207,9 +207,9 @@ let%expect_test "read data - tuple" =
        (Decl (decl_adtype (TupleAD (DataOnly DataOnly))) (decl_id x)
         (decl_type
          (Sized
-          (SArray
+          (SArray AoS
            (STuple
-            (SReal
+            ((SReal AoS)
              (SVector AoS
               ((pattern (Lit Int 20))
                (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))))
diff --git a/test/unit/Dataflow_utils.ml b/test/unit/Dataflow_utils.ml
index 53ca77da1..895049466 100644
--- a/test/unit/Dataflow_utils.ml
+++ b/test/unit/Dataflow_utils.ml
@@ -179,7 +179,7 @@ let%expect_test "Statement label map example" =
     {|
       ((1 (Block (2))) (2 (Block (3 4 5)))
        (3
-        (Decl (decl_adtype AutoDiffable) (decl_id i) (decl_type (Sized SInt))
+        (Decl (decl_adtype AutoDiffable) (decl_id i) (decl_type (Sized (SInt AoS)))
          (initialize true)))
        (4
         (Assignment ((LVariable i) ()) UInt
diff --git a/test/unit/Optimize.ml b/test/unit/Optimize.ml
index 4bcc5c60a..e42b494c9 100644
--- a/test/unit/Optimize.ml
+++ b/test/unit/Optimize.ml
@@ -336,7 +336,7 @@ let%expect_test "list collapsing" =
         (meta <opaque>))
        ((pattern
          (Decl (decl_adtype AutoDiffable) (decl_id inline_g_return_sym2__)
-          (decl_type (Sized SReal)) (initialize false)))
+          (decl_type (Sized (SReal AoS))) (initialize false)))
         (meta <opaque>))
        ((pattern
          (Block
@@ -3288,26 +3288,26 @@ let%expect_test "adlevel_optimization expressions" =
   [%expect
     {|
       (((pattern
-         (Decl (decl_adtype AutoDiffable) (decl_id w) (decl_type (Sized SReal))
-          (initialize true)))
+         (Decl (decl_adtype AutoDiffable) (decl_id w)
+          (decl_type (Sized (SReal AoS))) (initialize true)))
         (meta <opaque>))
        ((pattern
          (Block
           (((pattern
-             (Decl (decl_adtype DataOnly) (decl_id x) (decl_type (Sized SInt))
-              (initialize true)))
+             (Decl (decl_adtype DataOnly) (decl_id x)
+              (decl_type (Sized (SInt AoS))) (initialize true)))
             (meta <opaque>))
            ((pattern
-             (Decl (decl_adtype AutoDiffable) (decl_id y) (decl_type (Sized SReal))
-              (initialize true)))
+             (Decl (decl_adtype AutoDiffable) (decl_id y)
+              (decl_type (Sized (SReal AoS))) (initialize true)))
             (meta <opaque>))
            ((pattern
-             (Decl (decl_adtype AutoDiffable) (decl_id z) (decl_type (Sized SReal))
-              (initialize true)))
+             (Decl (decl_adtype AutoDiffable) (decl_id z)
+              (decl_type (Sized (SReal AoS))) (initialize true)))
             (meta <opaque>))
            ((pattern
              (Decl (decl_adtype DataOnly) (decl_id z_data)
-              (decl_type (Sized SReal)) (initialize true)))
+              (decl_type (Sized (SReal AoS))) (initialize true)))
             (meta <opaque>))
            ((pattern
              (IfElse
diff --git a/test/unit/Parse_tests.ml b/test/unit/Parse_tests.ml
index ed8bb4269..1779b6220 100644
--- a/test/unit/Parse_tests.ml
+++ b/test/unit/Parse_tests.ml
@@ -82,7 +82,7 @@ let%expect_test "parse minus unary" =
        (modelblock
         (((stmts
            (((stmt
-              (VarDecl (decl_type SReal) (transformation Identity)
+              (VarDecl (decl_type (SReal AoS)) (transformation Identity)
                (is_global false)
                (variables
                 (((identifier ((name x) (id_loc <opaque>))) (initial_value ()))))))
@@ -116,7 +116,7 @@ let%expect_test "parse unary over binary" =
      (modelblock
       (((stmts
          (((stmt
-            (VarDecl (decl_type SReal) (transformation Identity)
+            (VarDecl (decl_type (SReal AoS)) (transformation Identity)
              (is_global false)
              (variables
               (((identifier ((name x) (id_loc <opaque>)))
@@ -388,8 +388,9 @@ let%expect_test "parse crazy truncation example" =
            (((stmt
               (VarDecl
                (decl_type
-                (SArray
-                 (SArray SReal ((expr (IntNumeral 1)) (emeta ((loc <opaque>)))))
+                (SArray AoS
+                 (SArray AoS (SReal AoS)
+                  ((expr (IntNumeral 1)) (emeta ((loc <opaque>)))))
                  ((expr (IntNumeral 1)) (emeta ((loc <opaque>))))))
                (transformation Identity) (is_global false)
                (variables