diff --git a/src/analysis_and_optimization/Dataflow_utils.ml b/src/analysis_and_optimization/Dataflow_utils.ml
index 63111ca0a7..bf7892b103 100644
--- a/src/analysis_and_optimization/Dataflow_utils.ml
+++ b/src/analysis_and_optimization/Dataflow_utils.ml
@@ -24,7 +24,7 @@ let branching_traverse_statement stmt ~join ~init ~f =
     | IfElse (pred, then_s, else_s_opt) ->
         let s', c = f init then_s in
         Option.value_map else_s_opt
-          ~default:(s', IfElse (pred, c, None))
+          ~default:(join s' init, IfElse (pred, c, None))
           ~f:(fun else_s ->
             let s'', c' = f init else_s in
             (join s' s'', IfElse (pred, c, Some c')) )
@@ -109,7 +109,7 @@ let is_ctrl_flow pattern =
    set of a statement. It's advantageous to build them together because they both rely on
    some of the same Break, Continue and Return bookkeeping.
 *)
-let build_cf_graphs statement_map =
+let build_cf_graphs ?blocks_after_body:(blocks_after_body=true) statement_map =
   let rec build_cf_graph_rec (cf_parent : label option)
       ((in_state, in_map) : cf_state * (label, cf_edges) Map.Poly.t)
       (label : label) : cf_state * (label, cf_edges) Map.Poly.t =
@@ -119,16 +119,24 @@ let build_cf_graphs statement_map =
     let join (state1, map1) (state2, map2) =
       (join_cf_states state1 state2, union_maps_left map1 map2)
     in
+    (* This node is the parent of substatements, unless this is a Block, which
+       is visited after substatements *)
+    let substmt_preds =
+      match stmt with
+      | Block _ when blocks_after_body -> in_state.exits
+      | _ -> Set.Poly.singleton label
+    in
     (* The accumulated state after traversing substatements *)
     let substmt_state_unlooped, substmt_map =
       branching_fold_statement stmt ~join
-        ~init:({in_state with exits= Set.Poly.singleton label}, in_map)
+        ~init:({in_state with exits= substmt_preds}, in_map)
         ~f:(build_cf_graph_rec child_cf)
     in
     (* If the statement is a loop, we need to include the loop body exits as predecessors
          of the loop *)
     let substmt_state, predecessors =
-      let looped_state =
+      match stmt with
+      | For _ | While _ ->
         (* Loop statements are preceded by:
            1. The statements that come before the loop
            2. The natural exit points of the loop body
@@ -155,9 +163,13 @@ let build_cf_graphs statement_map =
             ]
         in
         ({substmt_state_unlooped with exits= loop_exits}, loop_predecessors)
-      in
-      match stmt with
-      | For _ | While _ -> looped_state
+      | Block _ when blocks_after_body ->
+        (* Block statements are preceded by the natural exit points of the block
+           body *)
+        let block_predecessors = substmt_state_unlooped.exits in
+        (* Block exits are just the block node *)
+        let block_exits = Set.Poly.singleton label in
+        ({substmt_state_unlooped with exits= block_exits}, block_predecessors)
       | _ -> (substmt_state_unlooped, in_state.exits)
     in
     (* Some statements interact with the break/return/continue states
@@ -223,6 +235,6 @@ let build_cf_graph statement_map =
   cf_graph
 
 (** See interface file *)
-let build_predecessor_graph statement_map =
-  let exits, pred_graph, _ = build_cf_graphs statement_map in
+let build_predecessor_graph ?blocks_after_body:(blocks_after_body=true) statement_map =
+    let exits, pred_graph, _ = build_cf_graphs ~blocks_after_body statement_map in
   (exits, pred_graph)
diff --git a/src/analysis_and_optimization/Dataflow_utils.mli b/src/analysis_and_optimization/Dataflow_utils.mli
index 566e436a36..11d5547b15 100644
--- a/src/analysis_and_optimization/Dataflow_utils.mli
+++ b/src/analysis_and_optimization/Dataflow_utils.mli
@@ -6,8 +6,9 @@ val union_maps_left :
   ('a, 'b) Map.Poly.t -> ('a, 'b) Map.Poly.t -> ('a, 'b) Map.Poly.t
 (** Union maps, preserving the left element in a collision *)
 
-val build_cf_graphs :
-     (label, (Expr.Typed.t, label) Stmt.Fixed.Pattern.t * 'm) Map.Poly.t
+val build_cf_graphs
+  : ?blocks_after_body:bool
+  -> (label, (Expr.Typed.t, label) Stmt.Fixed.Pattern.t * 'm) Map.Poly.t
   -> label Set.Poly.t
      * (label, label Set.Poly.t) Map.Poly.t
      * (label, label Set.Poly.t) Map.Poly.t
@@ -33,8 +34,9 @@ val build_cf_graph :
    and return statements shouldn't affect other branches of execution.
 *)
 
-val build_predecessor_graph :
-     (label, (Expr.Typed.t, label) Stmt.Fixed.Pattern.t * 'm) Map.Poly.t
+val build_predecessor_graph
+  : ?blocks_after_body:bool
+  -> (label, (Expr.Typed.t, label) Stmt.Fixed.Pattern.t * 'm) Map.Poly.t
   -> label Set.Poly.t * (label, label Set.Poly.t) Map.Poly.t
 (**
    Building the predecessor graph requires a traversal with state that includes the
diff --git a/src/analysis_and_optimization/Dependence_analysis.ml b/src/analysis_and_optimization/Dependence_analysis.ml
index 609c997405..aa66764d76 100644
--- a/src/analysis_and_optimization/Dependence_analysis.ml
+++ b/src/analysis_and_optimization/Dependence_analysis.ml
@@ -170,16 +170,6 @@ let prog_rhs_variables
   in
   union_map labels ~f:label_vars
 
-let rec var_declarations Stmt.Fixed.({pattern; _}) : string Set.Poly.t =
-  match pattern with
-  | Decl {decl_id; _} -> Set.Poly.singleton decl_id
-  | IfElse (_, s, None) | While (_, s) | For {body= s; _} -> var_declarations s
-  | IfElse (_, s1, Some s2) ->
-      Set.Poly.union (var_declarations s1) (var_declarations s2)
-  | Block slist | SList slist ->
-      Set.Poly.union_list (List.map ~f:var_declarations slist)
-  | _ -> Set.Poly.empty
-
 let stmt_uninitialized_variables (exceptions : string Set.Poly.t)
     (stmt : Stmt.Located.t) : (Location_span.t * string) Set.Poly.t =
   let flowgraph, flowgraph_to_mir =
diff --git a/src/analysis_and_optimization/Mir_utils.ml b/src/analysis_and_optimization/Mir_utils.ml
index 14ecaa69b6..ce9a95f41c 100644
--- a/src/analysis_and_optimization/Mir_utils.ml
+++ b/src/analysis_and_optimization/Mir_utils.ml
@@ -2,6 +2,16 @@ open Core_kernel
 open Middle
 open Dataflow_types
 
+let rec var_declarations Stmt.Fixed.({pattern; _}) : string Set.Poly.t =
+  match pattern with
+  | Decl {decl_id; _} -> Set.Poly.singleton decl_id
+  | IfElse (_, s, None) | While (_, s) | For {body= s; _} -> var_declarations s
+  | IfElse (_, s1, Some s2) ->
+    Set.Poly.union (var_declarations s1) (var_declarations s2)
+  | Block slist | SList slist ->
+    Set.Poly.union_list (List.map ~f:var_declarations slist)
+  | _ -> Set.Poly.empty
+
 let rec map_rec_expr f e =
   let recurse = map_rec_expr f in
   Expr.Fixed.{e with pattern= f (Pattern.map recurse e.pattern)}
@@ -189,33 +199,51 @@ let rec summation_terms (Expr.Fixed.({pattern; _}) as rhs) =
 let stmt_of_block b =
   Stmt.Fixed.{pattern= SList b; meta= Stmt.Located.Meta.empty}
 
-let rec subst_expr m (Expr.Fixed.({pattern; _}) as e) =
-  match pattern with
-  | Var s -> ( match Map.find m s with Some e' -> e' | None -> e )
-  | _ -> Expr.Fixed.{e with pattern= Pattern.map (subst_expr m) pattern}
+let rec fn_subst_expr m e =
+  match m e with
+  | Some e' ->
+    (* let print_expr (e:Expr.Typed.t) = *)
+      (* [%sexp (e.pattern : Expr.Typed.Meta.t Expr.Fixed.t Expr.Fixed.Pattern.t)] |> Sexp.to_string *)
+    (* in *)
+    (* let _ = print_endline ("Replaced expr: " ^ print_expr e ^ " -> " ^ print_expr e') in *)
+    e'
+  | _ -> Expr.Fixed.{e with pattern= Pattern.map (fn_subst_expr m) e.pattern}
 
-let subst_idx m = Index.map (subst_expr m)
+let fn_subst_idx m = Index.map (fn_subst_expr m)
 
-let subst_stmt_base_helper g h b =
+let fn_subst_stmt_base_helper g h b =
   Stmt.Fixed.Pattern.(
     match b with
     | Assignment ((x, ut, l), e2) -> Assignment ((x, ut, List.map ~f:h l), g e2)
     | x -> map g (fun y -> y) x)
 
-let subst_stmt_base m = subst_stmt_base_helper (subst_expr m) (subst_idx m)
-let subst_stmt m = map_rec_stmt_loc (subst_stmt_base m)
+let fn_subst_stmt_base m = fn_subst_stmt_base_helper (fn_subst_expr m) (fn_subst_idx m)
+let fn_subst_stmt m = map_rec_stmt_loc (fn_subst_stmt_base m)
 
-let rec expr_subst_expr m e =
-  match Map.find m e with
-  | Some e' -> e'
-  | None ->
-      Expr.Fixed.{e with pattern= Pattern.map (expr_subst_expr m) e.pattern}
+let name_map m (e : Expr.Typed.t) =
+  match e.pattern with
+  | Var s ->
+    (match Map.Poly.find m s with
+     | Some s' -> Some {e with pattern = Var s'}
+     | None -> None)
+  | _ -> None
 
-let expr_subst_idx m = Index.map (expr_subst_expr m)
+let name_subst_stmt m = fn_subst_stmt (name_map m)
 
-let expr_subst_stmt_base m =
-  subst_stmt_base_helper (expr_subst_expr m) (expr_subst_idx m)
+let var_map m (e : Expr.Typed.t) =
+  match e.pattern with
+  | Var s -> Map.find m s
+  | _ -> None
+let subst_expr m e = fn_subst_expr (var_map m) e
+let subst_idx m = Index.map (subst_expr m)
+let subst_stmt_base m = fn_subst_stmt_base_helper (subst_expr m) (subst_idx m)
+let subst_stmt m = map_rec_stmt_loc (subst_stmt_base m)
 
+let expr_map m (e : Expr.Typed.t) = Map.find m e
+let expr_subst_expr m e = fn_subst_expr (expr_map m) e
+let expr_subst_idx m = Index.map (expr_subst_expr m)
+let expr_subst_stmt_base m =
+  fn_subst_stmt_base_helper (expr_subst_expr m) (expr_subst_idx m)
 let expr_subst_stmt m = map_rec_stmt_loc (expr_subst_stmt_base m)
 
 let rec expr_depth Expr.Fixed.({pattern; _}) =
@@ -278,12 +306,12 @@ let rec update_expr_ad_levels autodiffable_variables
       let e2 = update_expr_ad_levels autodiffable_variables e2 in
       { pattern= EOr (e1, e2)
       ; meta= {e.meta with adlevel= ad_level_sup [e1; e2]} }
-  | Indexed (e, i_list) ->
-      let e = update_expr_ad_levels autodiffable_variables e in
+  | Indexed (ixed, i_list) ->
+      let ixed = update_expr_ad_levels autodiffable_variables ixed in
       let i_list =
         List.map ~f:(update_idx_ad_levels autodiffable_variables) i_list
       in
-      { pattern= Indexed (e, i_list)
+      { pattern= Indexed (ixed, i_list)
       ; meta=
           { e.meta with
             adlevel= ad_level_sup (e :: List.concat_map ~f:Index.bounds i_list)
diff --git a/src/analysis_and_optimization/Mir_utils.mli b/src/analysis_and_optimization/Mir_utils.mli
index 6e409838fc..20f1f3e680 100644
--- a/src/analysis_and_optimization/Mir_utils.mli
+++ b/src/analysis_and_optimization/Mir_utils.mli
@@ -1,6 +1,8 @@
 open Core_kernel
 open Middle
 open Dataflow_types
+val var_declarations :
+  ('a, 'b) Stmt.Fixed.t -> string Set.Poly.t
 
 val map_rec_expr :
      (Expr.Typed.t Expr.Fixed.Pattern.t -> Expr.Typed.t Expr.Fixed.Pattern.t)
@@ -144,6 +146,11 @@ val subst_stmt :
   (string, Expr.Typed.t) Map.Poly.t -> Stmt.Located.t -> Stmt.Located.t
 (** Substitute variables occurring anywhere in a statement according to the provided Map. *)
 
+val name_subst_stmt :
+  (string, string) Map.Poly.t -> Stmt.Located.t -> Stmt.Located.t
+(** Substitute subexpressions occurring anywhere in a statement according to the provided Map. *)
+
+
 val expr_subst_expr :
   Expr.Typed.t Expr.Typed.Map.t -> Expr.Typed.t -> Expr.Typed.t
 (** Substitute subexpressions in an expression according to the provided Map, trying
diff --git a/src/analysis_and_optimization/Monotone_framework.ml b/src/analysis_and_optimization/Monotone_framework.ml
index cf2d681878..e721ab72b5 100644
--- a/src/analysis_and_optimization/Monotone_framework.ml
+++ b/src/analysis_and_optimization/Monotone_framework.ml
@@ -5,8 +5,84 @@ open Monotone_framework_sigs
 open Mir_utils
 open Middle
 
+let preserve_stability = false
+
+(** Debugging tool to print out MFP sets **) 
+let print_mfp to_string (mfp : (int, 'a entry_exit) Map.Poly.t) (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t) : unit =
+  let print_set s =
+    [%sexp (Set.Poly.map ~f:to_string s : string Set.Poly.t)] |> Sexp.to_string_hum
+  in
+  let print_stmt s =
+    [%sexp (s : Stmt.Located.Non_recursive.t)] |> Sexp.to_string_hum
+  in
+  Map.iteri mfp ~f:(fun ~key ~data ->
+      print_endline (string_of_int key ^ ":\n "
+                     ^ print_stmt (Map.Poly.find_exn flowgraph_to_mir key) ^ ":\n "
+                     ^ print_set data.entry ^ " \t-> " ^ print_set data.exit))
+
+(** Calculate the free (non-bound) variables in an expression *)
+let rec free_vars_expr (e : Expr.Typed.t) =
+  match e.pattern with
+  | Var x -> Set.Poly.singleton x
+  | Lit (_, _) -> Set.Poly.empty
+  | FunApp (_, f, l) ->
+      Set.Poly.union_list (Set.Poly.singleton f :: List.map ~f:free_vars_expr l)
+  | TernaryIf (e1, e2, e3) ->
+      Set.Poly.union_list (List.map ~f:free_vars_expr [e1; e2; e3])
+  | Indexed (e, l) ->
+      Set.Poly.union_list (free_vars_expr e :: List.map ~f:free_vars_idx l)
+  | EAnd (e1, e2) | EOr (e1, e2) ->
+      Set.Poly.union_list (List.map ~f:free_vars_expr [e1; e2])
+
+(** Calculate the free (non-bound) variables in an index*)
+and free_vars_idx (i : Expr.Typed.t Index.t) =
+  match i with
+  | All -> Set.Poly.empty
+  | Single e | Upfrom e | MultiIndex e -> free_vars_expr e
+  | Between (e1, e2) -> Set.Poly.union (free_vars_expr e1) (free_vars_expr e2)
+
+(** Calculate the free (non-bound) variables in a statement *)
+let rec free_vars_stmt
+    (s : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t) =
+  match s with
+  | Assignment ((_, _, []), e) | Return (Some e) | TargetPE e ->
+      free_vars_expr e
+  | Assignment ((_, _, l), e) ->
+      Set.Poly.union_list (free_vars_expr e :: List.map ~f:free_vars_idx l)
+  | NRFunApp (_, f, l) ->
+      Set.Poly.union_list (Set.Poly.singleton f :: List.map ~f:free_vars_expr l)
+  | IfElse (e, b1, Some b2) ->
+      Set.Poly.union_list
+        [free_vars_expr e; free_vars_stmt b1.pattern; free_vars_stmt b2.pattern]
+  | IfElse (e, b, None) | While (e, b) ->
+      Set.Poly.union (free_vars_expr e) (free_vars_stmt b.pattern)
+  | For {lower= e1; upper= e2; body= b; _} ->
+      Set.Poly.union_list
+        [free_vars_expr e1; free_vars_expr e2; free_vars_stmt b.pattern]
+  | Block l | SList l ->
+      Set.Poly.union_list (List.map ~f:(fun s -> free_vars_stmt s.pattern) l)
+  | Decl _ | Break | Continue | Return None | Skip -> Set.Poly.empty
+
+(** A variation on free_vars_stmt, where we do not recursively count free
+    variables in sub statements  *)
+let top_free_vars_stmt
+    (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t)
+    (s : (Expr.Typed.t, int) Stmt.Fixed.Pattern.t) =
+  match s with
+  | Assignment _ | Return _ | TargetPE _ | NRFunApp _ | Decl _ | Break
+   |Continue | Skip ->
+      free_vars_stmt
+        (statement_stmt_loc_of_statement_stmt_loc_num flowgraph_to_mir s)
+  | While (e, _) | IfElse (e, _, _) -> free_vars_expr e
+  | For {lower= e1; upper= e2; _} ->
+      Set.Poly.union_list [free_vars_expr e1; free_vars_expr e2]
+  | Block _ | SList _ -> Set.Poly.empty
+
+
 (** Compute the inverse flowgraph of a Stan statement (for reverse analyses) *)
-let inverse_flowgraph_of_stmt (stmt : Stmt.Located.t) :
+let inverse_flowgraph_of_stmt
+    ?blocks_after_body:(blocks_after_body=true)
+    (stmt : Stmt.Located.t) :
     (module FLOWGRAPH with type labels = int)
     * (int, Stmt.Located.Non_recursive.t) Map.Poly.t =
   let flowgraph_to_mir =
@@ -16,7 +92,7 @@ let inverse_flowgraph_of_stmt (stmt : Stmt.Located.t) :
       stmt
   in
   let initials, successors =
-    Dataflow_utils.build_predecessor_graph flowgraph_to_mir
+    Dataflow_utils.build_predecessor_graph ~blocks_after_body flowgraph_to_mir
   in
   ( ( module struct
       type labels = int
@@ -58,8 +134,10 @@ let reverse (type l) (module F : FLOWGRAPH with type labels = l) =
     with type labels = l )
 
 (** Compute the forward flowgraph of a Stan statement (for forward analyses) *)
-let forward_flowgraph_of_stmt stmt =
-  let inv_flowgraph = inverse_flowgraph_of_stmt stmt in
+let forward_flowgraph_of_stmt
+    ?blocks_after_body:(blocks_after_body=true)
+    stmt =
+  let inv_flowgraph = inverse_flowgraph_of_stmt ~blocks_after_body stmt in
   (reverse (fst inv_flowgraph), snd inv_flowgraph)
 
 (**  The lattice of sets of some values, with the inclusion order, set union
@@ -145,6 +223,7 @@ let dual_partial_function_lattice (type dv cv)
   ( module struct
     type properties = (Dom.vals, Codom.vals) Map.Poly.t
 
+    (* intersection *)
     let lub s1 s2 =
       let f ~key ~data = Map.find s2 key = Some data in
       Map.filteri ~f s1
@@ -221,9 +300,12 @@ let constant_propagation_transfer
             ( match mir_node with
             (* TODO: we are currently only propagating constants for scalars.
              We could do the same for matrix and array expressions if we wanted. *)
-            | Assignment ((s, _, []), e) -> (
+            | Assignment ((s, t, []), e) -> (
               match Partial_evaluator.eval_expr (subst_expr m e) with
-              | {pattern= Lit (_, _); _} as e' -> Map.set m ~key:s ~data:e'
+                | {pattern= Lit (_, _); _} as e'
+                  when not (preserve_stability &&
+                            UnsizedType.is_autodiffable t) ->
+                  Map.set m ~key:s ~data:e'
               | _ -> Map.remove m s )
             | Decl {decl_id= s; _} | Assignment ((s, _, _ :: _), _) ->
                 Map.remove m s
@@ -239,6 +321,14 @@ let constant_propagation_transfer
     with type labels = int
      and type properties = (string, Expr.Typed.t) Map.Poly.t option )
 
+let label_top_decls
+  (flowgraph_to_mir : (int, Middle.Stmt.Located.Non_recursive.t) Map.Poly.t)
+  label : string Set.Poly.t =
+  let stmt = Map.Poly.find_exn flowgraph_to_mir label in
+  match stmt.pattern with
+  | Decl {decl_id= s; _} -> Set.Poly.singleton s
+  | _ -> Set.Poly.empty
+
 (** The transfer function for an expression propagation analysis,
     AKA forward substitution (see page 396 of Muchnick) *)
 let expression_propagation_transfer
@@ -254,21 +344,35 @@ let expression_propagation_transfer
       | None -> None
       | Some m ->
           let mir_node = (Map.find_exn flowgraph_to_mir l).pattern in
+          let kill_var m v =
+            Map.filteri m ~f:(fun ~key ~data ->
+                not (key = v || Set.Poly.mem (free_vars_expr data) v))
+          in
           Some
             ( match mir_node with
             (* TODO: we are currently only propagating constants for scalars.
              We could do the same for matrix and array expressions if we wanted. *)
-            | Middle.Stmt.Fixed.Pattern.Assignment ((s, _, []), e) ->
-                if can_side_effect_expr e then m
-                else Map.set m ~key:s ~data:(subst_expr m e)
+            | Middle.Stmt.Fixed.Pattern.Assignment ((s, t, []), e) ->
+              let m' = kill_var m s in
+              if can_side_effect_expr e ||
+                 Set.Poly.mem (free_vars_expr e) s ||
+                 (preserve_stability && UnsizedType.is_autodiffable t)
+              then
+                m'
+              else Map.set m ~key:s ~data:(subst_expr m e)
             | Decl {decl_id= s; _} | Assignment ((s, _, _ :: _), _) ->
-                Map.remove m s
+              kill_var m s
+            | Block b ->
+              let kills =
+                Set.Poly.union_list (List.map ~f:(label_top_decls flowgraph_to_mir) b)
+              in
+              Set.Poly.fold kills ~init:m ~f:kill_var
             | TargetPE _
              |NRFunApp (_, _, _)
              |Break | Continue | Return _ | Skip
              |IfElse (_, _, _)
              |While (_, _)
-             |For _ | Block _ | SList _ ->
+             |For _ | SList _ ->
                 m )
   end
   : TRANSFER_FUNCTION
@@ -277,6 +381,7 @@ let expression_propagation_transfer
 
 (** The transfer function for a copy propagation analysis *)
 let copy_propagation_transfer
+    (globals : string Set.Poly.t)
     (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t) =
   ( module struct
     type labels = int
@@ -287,19 +392,31 @@ let copy_propagation_transfer
       | None -> None
       | Some m ->
           let mir_node = (Map.find_exn flowgraph_to_mir l).pattern in
+          let kill_var m v =
+            Map.filteri m ~f:(fun ~key ~(data : Expr.Typed.t) ->
+                not (key = v || data.pattern = Var v))
+          in
           Some
             ( match mir_node with
-            | Assignment ((s, _, []), {pattern= Var t; meta}) ->
-                Map.set m ~key:s ~data:Expr.Fixed.{pattern= Var t; meta}
-            | Decl {decl_id= s; _} | Assignment ((s, _, _ :: _), _) ->
-                Map.remove m s
-            | Assignment (_, _)
-             |TargetPE _
-             |NRFunApp (_, _, _)
-             |Break | Continue | Return _ | Skip
-             |IfElse (_, _, _)
-             |While (_, _)
-             |For _ | Block _ | SList _ ->
+              | Assignment ((s, _, []), {pattern= Var t; meta}) ->
+                let m' = kill_var m s in
+                if (Set.Poly.mem globals s) then
+                  m'
+                else
+                  Map.set m' ~key:s ~data:Expr.Fixed.{pattern= Var t; meta}
+              | Decl {decl_id= s; _} | Assignment ((s, _, _), _) ->
+                kill_var m s
+              | Block b ->
+                let kills =
+                  Set.Poly.union_list (List.map ~f:(label_top_decls flowgraph_to_mir) b)
+                in
+                Set.Poly.fold kills ~init:m ~f:kill_var
+              |TargetPE _
+              |NRFunApp (_, _, _)
+              |Break | Continue | Return _ | Skip
+              |IfElse (_, _, _)
+              |While (_, _)
+              |For _ | SList _ ->
                 m )
   end
   : TRANSFER_FUNCTION
@@ -389,66 +506,9 @@ let initialized_vars_transfer
   : TRANSFER_FUNCTION
     with type labels = int and type properties = string Set.Poly.t )
 
-(** Calculate the free (non-bound) variables in an expression *)
-let rec free_vars_expr (e : Expr.Typed.t) =
-  match e.pattern with
-  | Var x -> Set.Poly.singleton x
-  | Lit (_, _) -> Set.Poly.empty
-  | FunApp (_, f, l) ->
-      Set.Poly.union_list (Set.Poly.singleton f :: List.map ~f:free_vars_expr l)
-  | TernaryIf (e1, e2, e3) ->
-      Set.Poly.union_list (List.map ~f:free_vars_expr [e1; e2; e3])
-  | Indexed (e, l) ->
-      Set.Poly.union_list (free_vars_expr e :: List.map ~f:free_vars_idx l)
-  | EAnd (e1, e2) | EOr (e1, e2) ->
-      Set.Poly.union_list (List.map ~f:free_vars_expr [e1; e2])
-
-(** Calculate the free (non-bound) variables in an index*)
-and free_vars_idx (i : Expr.Typed.t Index.t) =
-  match i with
-  | All -> Set.Poly.empty
-  | Single e | Upfrom e | MultiIndex e -> free_vars_expr e
-  | Between (e1, e2) -> Set.Poly.union (free_vars_expr e1) (free_vars_expr e2)
-
-(** Calculate the free (non-bound) variables in a statement *)
-let rec free_vars_stmt
-    (s : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t) =
-  match s with
-  | Assignment ((_, _, []), e) | Return (Some e) | TargetPE e ->
-      free_vars_expr e
-  | Assignment ((_, _, l), e) ->
-      Set.Poly.union_list (free_vars_expr e :: List.map ~f:free_vars_idx l)
-  | NRFunApp (_, f, l) ->
-      Set.Poly.union_list (Set.Poly.singleton f :: List.map ~f:free_vars_expr l)
-  | IfElse (e, b1, Some b2) ->
-      Set.Poly.union_list
-        [free_vars_expr e; free_vars_stmt b1.pattern; free_vars_stmt b2.pattern]
-  | IfElse (e, b, None) | While (e, b) ->
-      Set.Poly.union (free_vars_expr e) (free_vars_stmt b.pattern)
-  | For {lower= e1; upper= e2; body= b; _} ->
-      Set.Poly.union_list
-        [free_vars_expr e1; free_vars_expr e2; free_vars_stmt b.pattern]
-  | Block l | SList l ->
-      Set.Poly.union_list (List.map ~f:(fun s -> free_vars_stmt s.pattern) l)
-  | Decl _ | Break | Continue | Return None | Skip -> Set.Poly.empty
-
-(** A variation on free_vars_stmt, where we do not recursively count free
-    variables in sub statements  *)
-let top_free_vars_stmt
-    (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t)
-    (s : (Expr.Typed.t, int) Stmt.Fixed.Pattern.t) =
-  match s with
-  | Assignment _ | Return _ | TargetPE _ | NRFunApp _ | Decl _ | Break
-   |Continue | Skip ->
-      free_vars_stmt
-        (statement_stmt_loc_of_statement_stmt_loc_num flowgraph_to_mir s)
-  | While (e, _) | IfElse (e, _, _) -> free_vars_expr e
-  | For {lower= e1; upper= e2; _} ->
-      Set.Poly.union_list [free_vars_expr e1; free_vars_expr e2]
-  | Block _ | SList _ -> Set.Poly.empty
-
 (** The transfer function for a live variables analysis *)
 let live_variables_transfer
+    (never_kill : string Set.Poly.t)
     (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t) =
   ( module struct
     type labels = int
@@ -470,7 +530,7 @@ let live_variables_transfer
          |Assignment ((_, _, _ :: _), _) ->
             Set.Poly.empty
       in
-      transfer_gen_kill p gen kill
+      transfer_gen_kill p gen (Set.Poly.diff kill never_kill)
   end
   : TRANSFER_FUNCTION
     with type labels = int and type properties = string Set.Poly.t )
@@ -742,7 +802,7 @@ let autodiff_level_rev_transfer
         | Decl {decl_id; _} -> Set.Poly.singleton decl_id
         | _ -> Set.Poly.empty
       in
-      transfer_gen_kill_alt p gen kill
+      transfer_gen_kill_alt p gen kill (* gens and then kills *)
   end
   : TRANSFER_FUNCTION
     with type labels = int and type properties = string Set.Poly.t )
@@ -930,28 +990,41 @@ let initialized_vars_mfp (total : string Set.Poly.t)
   in
   Mf.mfp ()
 
+let globals (prog : Program.Typed.t) =
+  Set.Poly.union_list
+    [ Set.Poly.of_list (List.map ~f:fst prog.output_vars)
+    (* It is not strictly necessary to exclude data variables from DCE.
+       However,
+       1. We don't currently check for usage of data variables in
+          corners of the MIR, such as in the sizes of parameters
+       2. There is code added in codegen that is never represented in
+          the MIR that may use data variables as if they're initialized
+    *)
+    ; Set.Poly.of_list (List.map ~f:fst prog.input_vars)
+    ; Set.Poly.union_list (List.map ~f:var_declarations prog.prepare_data)
+    ; Set.Poly.singleton "target"
+    ]
+
 (** Monotone framework instance for live_variables analysis. Expects reverse
     flowgraph. *)
 let live_variables_mfp (prog : Program.Typed.t)
     (module Rev_Flowgraph : Monotone_framework_sigs.FLOWGRAPH
       with type labels = int)
     (flowgraph_to_mir : (int, Stmt.Located.Non_recursive.t) Map.Poly.t) =
+  let never_kill = globals prog in
   let variables =
     ( module struct
       type vals = string
 
       (* NOTE: global generated quantities, (transformed) parameters and target are always observable
    so should be live. *)
-      let initial =
-        Set.Poly.add
-          (Set.Poly.of_list (List.map ~f:fst prog.output_vars))
-          "target"
+      let initial = never_kill
     end
     : INITIALTYPE
       with type vals = string )
   in
   let (module Lattice) = powerset_lattice variables in
-  let (module Transfer) = live_variables_transfer flowgraph_to_mir in
+  let (module Transfer) = live_variables_transfer never_kill flowgraph_to_mir in
   let (module Mf) =
     monotone_framework (module Rev_Flowgraph) (module Lattice) (module Transfer)
   in
diff --git a/src/analysis_and_optimization/Optimize.ml b/src/analysis_and_optimization/Optimize.ml
index da1235f53f..d9a76b833c 100644
--- a/src/analysis_and_optimization/Optimize.ml
+++ b/src/analysis_and_optimization/Optimize.ml
@@ -4,6 +4,8 @@ open Common
 open Middle
 open Mir_utils
 
+let preserve_stability = false
+
 (**
    Apply the transformation to each function body and to the rest of the program as one
    block.
@@ -47,24 +49,32 @@ let transform_program (mir : Program.Typed.t)
    Apply the transformation to each function body and to each program block separately.
 *)
 let transform_program_blockwise (mir : Program.Typed.t)
-    (transform : Stmt.Located.t -> Stmt.Located.t) : Program.Typed.t =
-  let transform' s =
-    match transform {pattern= SList s; meta= Location_span.empty} with
+    (transform : Stmt.Located.t Program.fun_def option -> Stmt.Located.t ->
+     Stmt.Located.t) : Program.Typed.t =
+  let transform' fd s =
+    match transform fd {pattern= SList s; meta= Location_span.empty} with
     | {pattern= SList l; _} -> l
     | _ ->
         raise
           (Failure "Something went wrong with program transformation packing!")
   in
+  (* Right now, we have an implicit constraint where if fdbody = Skip, the
+     fun_def is a function declaration. When that's the case we don't want
+     to change it from Skip.*)
+  let non_decl_functions =
+    List.filter ~f:(fun def -> def.fdbody.pattern <> Skip) mir.functions_block
+  in
   let transformed_functions =
-    List.map mir.functions_block ~f:(fun fs ->
-        {fs with fdbody= transform fs.fdbody} )
+    List.map non_decl_functions ~f:(fun fs ->
+        {fs with fdbody= transform (Some fs) fs.fdbody} )
   in
   { mir with
     functions_block= transformed_functions
-  ; prepare_data= transform' mir.prepare_data
-  ; transform_inits= transform' mir.transform_inits
-  ; log_prob= transform' mir.log_prob
-  ; generate_quantities= transform' mir.generate_quantities }
+  ; prepare_data= transform' None mir.prepare_data
+  ; transform_inits= transform' None mir.transform_inits
+  ; log_prob= transform' None mir.log_prob
+  ; generate_quantities= transform' None mir.generate_quantities
+  }
 
 let map_no_loc l =
   List.map ~f:(fun s -> Stmt.Fixed.{pattern= s; meta= Location_span.empty}) l
@@ -78,81 +88,120 @@ let slist_concat_no_loc l stmt =
 let replace_fresh_local_vars s' =
   let f m = function
     | Stmt.Fixed.Pattern.Decl {decl_adtype; decl_type; decl_id} ->
-        let fresh_name = Gensym.generate () in
-        ( Stmt.Fixed.Pattern.Decl {decl_adtype; decl_id= fresh_name; decl_type}
-        , Map.Poly.set m ~key:decl_id
-            ~data:
-              Expr.Fixed.
-                { pattern= Var fresh_name
-                ; meta=
-                    Expr.Typed.Meta.
-                      { type_= Type.to_unsized decl_type
-                      ; adlevel= decl_adtype
-                      ; loc= Location_span.empty } } )
+      let new_name = match Map.Poly.find m decl_id with
+        | Some existing -> existing
+        | None -> Gensym.generate ~prefix:"inline_" ()
+      in
+      ( Stmt.Fixed.Pattern.Decl {decl_adtype; decl_id= new_name; decl_type}
+      , Map.Poly.set m ~key:decl_id ~data:new_name
+      )
+    | Stmt.Fixed.Pattern.For {loopvar; lower; upper; body} ->
+      let new_name = match Map.Poly.find m loopvar with
+        | Some existing -> existing
+        | None -> Gensym.generate ~prefix:"inline_" ()
+      in
+      ( Stmt.Fixed.Pattern.For
+          { loopvar= new_name
+          ; lower= lower
+          ; upper= upper
+          ; body= body }
+      , Map.Poly.set m ~key:loopvar ~data:new_name)
     | Assignment ((var_name, ut, l), e) ->
         let var_name =
           match Map.Poly.find m var_name with
           | None -> var_name
-          | Some Expr.Fixed.({pattern= Var var_name; _}) -> var_name
-          | Some e -> raise_s [%sexp (e : Expr.Typed.t)]
+          | Some var_name -> var_name
         in
         (Stmt.Fixed.Pattern.Assignment ((var_name, ut, l), e), m)
     | x -> (x, m)
   in
   let s, m = map_rec_state_stmt_loc f Map.Poly.empty s' in
-  subst_stmt m s
-
-let replace_fresh_local_vars_triple (d_list, s_list, e) =
-  let s =
-    slist_no_loc
-      ([slist_no_loc d_list] @ [slist_no_loc s_list] @ [Return (Some e)])
-  in
-  let s =
-    (replace_fresh_local_vars {pattern= s; meta= Location_span.empty}).pattern
-  in
-  match s with
-  | SList
-      [ {pattern= SList d_list; _}
-      ; {pattern= SList s_list; _}
-      ; {pattern= Return (Some e); _} ] ->
-      ( List.map ~f:(fun x -> x.pattern) d_list
-      , List.map ~f:(fun x -> x.pattern) s_list
-      , e )
-  | _ ->
-      raise_s [%sexp (s : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t)]
+  name_subst_stmt m s
 
 let subst_args_stmt args es =
   let m = Map.Poly.of_alist_exn (List.zip_exn args es) in
   subst_stmt m
 
 (* TODO: only handle early returns if that's necessary *)
+(* The strategy here is to wrap the function body in a dummy loop, then replace
+   returns with breaks. One issue is early return from internal loops - in
+   those cases, a break would only break out of the inner loop. The solution is
+   a flag variable to indicate whether a 'return' break has been called, and
+   then to check if that flag is set after each loop. Then, if a 'return' break
+   is called from an inner loop, there's a cascade of breaks all the way out of
+   the dummy loop. *)
 let handle_early_returns opt_triple b =
+  let returned = Gensym.generate ~prefix:"inline_" () in
   let f = function
     | Stmt.Fixed.Pattern.Return opt_ret -> (
-      match (opt_triple, opt_ret) with
-      | None, None -> Stmt.Fixed.Pattern.Break
-      | Some (Some _, _, name), Some e ->
+        match (opt_triple, opt_ret) with
+        | None, None -> Stmt.Fixed.Pattern.Break
+        | Some (Some _, _, name), Some e ->
           SList
             [ Stmt.Fixed.
+                { pattern= Assignment ((returned, UInt, []),
+                                       Expr.Fixed.
+                                         { pattern= Lit (Int, "1")
+                                         ; meta=
+                                             Expr.Typed.Meta.
+                                               {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} })
+                ; meta= Location_span.empty }
+            ; Stmt.Fixed.
                 { pattern= Assignment ((name, Expr.Typed.type_of e, []), e)
                 ; meta= Location_span.empty }
             ; {pattern= Break; meta= Location_span.empty} ]
-      | _, _ -> raise_s [%sexp ("" : string)] )
+        | _, _ -> raise_s [%sexp ("" : string)] )
+    | (Stmt.Fixed.Pattern.For _ as loop) ->
+      Stmt.Fixed.Pattern.SList
+        [ Stmt.Fixed.
+            { pattern= loop
+            ; meta= Location_span.empty }
+        ; Stmt.Fixed.
+            { pattern= IfElse
+                  ( Expr.Fixed.
+                      { pattern= Var returned
+                      ; meta=
+                          Expr.Typed.Meta.
+                            {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} }
+                  , {pattern= Break; meta= Location_span.empty}
+                  , None)
+            ; meta= Location_span.empty }
+        ]
     | x -> x
   in
-  Stmt.Fixed.Pattern.For
-    { loopvar= Gensym.generate ()
-    ; lower=
-        Expr.Fixed.
-          { pattern= Lit (Int, "1")
-          ; meta=
-              Expr.Typed.Meta.
-                {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} }
-    ; upper=
-        { pattern= Lit (Int, "1")
-        ; meta= {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} }
-    ; body= map_rec_stmt_loc f b }
+  Stmt.Fixed.Pattern.SList
+    [ Stmt.Fixed.
+        { pattern= Decl
+              { decl_adtype= DataOnly
+              ; decl_id= returned
+              ; decl_type= Sized SInt
+              }
+        ; meta= Location_span.empty }
+    ; Stmt.Fixed.
+        { pattern= Assignment ((returned, UInt, []),
+                               Expr.Fixed.
+                                 { pattern= Lit (Int, "0")
+                                 ; meta=
+                                     Expr.Typed.Meta.
+                                       {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} })
+        ; meta= Location_span.empty }
+    ; Stmt.Fixed.
+        { pattern= Stmt.Fixed.Pattern.For
+              { loopvar= Gensym.generate ~prefix:"inline_" ()
+              ; lower=
+                  Expr.Fixed.
+                    { pattern= Lit (Int, "1")
+                    ; meta=
+                        Expr.Typed.Meta.
+                          {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} }
+              ; upper=
+                  { pattern= Lit (Int, "1")
+                  ; meta= {type_= UInt; adlevel= DataOnly; loc= Location_span.empty} }
+              ; body= map_rec_stmt_loc f b }
+        ; meta= Location_span.empty }
+    ]
 
+(* Triple is (declaration list, statement list, return expression) *)
 let rec inline_function_expression adt fim (Expr.Fixed.({pattern; _}) as e) =
   match pattern with
   | Var _ -> ([], [], e)
@@ -170,17 +219,21 @@ let rec inline_function_expression adt fim (Expr.Fixed.({pattern; _}) as e) =
       match Map.find fim s with
       | None -> (d_list, s_list, {e with pattern= FunApp (t, s, es)})
       | Some (rt, args, b) ->
-          let x = Gensym.generate () in
-          let b = handle_early_returns (Some (rt, adt, x)) b in
-          let d_list2, s_list2, e =
-            replace_fresh_local_vars_triple
-              ( [ Decl
+          let x = Gensym.generate ~prefix:"inline_" () in
+          let handle = handle_early_returns (Some (rt, adt, x)) in
+          let d_list2, s_list2, (e:Expr.Typed.t) =
+              ( [ Stmt.Fixed.Pattern.Decl
                     { decl_adtype= adt
                     ; decl_id= x
                     ; decl_type= Option.value_exn rt } ]
-              , [ (subst_args_stmt args es
-                     {pattern= b; meta= Location_span.empty})
-                    .pattern ]
+                (* We should minimize the code that's having its variables
+                   replaced to avoid conflict with the (two) new dummy
+                   variables introduced by inlining *)
+              , [ handle
+                    (replace_fresh_local_vars
+                       (subst_args_stmt args es
+                          b))
+                ]
               , { pattern= Var x
                 ; meta=
                     Expr.Typed.Meta.
@@ -362,22 +415,31 @@ let rec inline_function_statement adt fim Stmt.Fixed.({pattern; meta}) =
 
 let create_function_inline_map adt l =
   (* We only add the first definition for each function to the inline map.
-   This will make sure we do not inline recursive functions. *)
-  let f accum fundef =
-    match fundef with Program.({fdname; fdargs; fdbody; fdrt; _}) -> (
-      match
-        Map.add accum ~key:fdname
-          ~data:
+     This will make sure we do not inline recursive functions.
+     We also don't want to add any function declaration (as opposed to
+     definitions), because that would replace the function call with a Skip.
+  *)
+  let f (accum, visited) Program.({fdname; fdargs; fdbody; fdrt; _}) =
+    if Set.mem visited fdname then
+      (accum, visited)
+    else
+      let accum' = match fdbody with
+        | Stmt.Fixed.{pattern= Stmt.Fixed.Pattern.Skip; _} -> accum
+        | _ ->
+          let data =
             ( Option.map ~f:(fun x -> Type.Unsized x) fdrt
             , List.map ~f:(fun (_, name, _) -> name) fdargs
             , inline_function_statement adt accum fdbody )
-      with
-      | `Ok m -> m
-      | `Duplicate -> accum )
+          in
+          match Map.add accum ~key:fdname ~data:data with
+          | `Ok m -> m
+          | `Duplicate -> accum
+      in
+      let visited' = Set.add visited fdname in
+      (accum', visited')
   in
-  Map.filter
-    ~f:(fun (_, _, v) -> v.pattern <> Skip)
-    (List.fold l ~init:Map.Poly.empty ~f)
+  let (accum, _) = List.fold l ~init:(Map.Poly.empty, Set.Poly.empty) ~f in
+  accum
 
 let function_inlining (mir : Program.Typed.t) =
   let dataonly_inline_map =
@@ -421,7 +483,7 @@ let rec contains_top_break_or_continue Stmt.Fixed.({pattern; _}) =
       | None -> false
       | Some b -> contains_top_break_or_continue b )
 
-let unroll_static_loops_statement =
+let unroll_static_loops_statement _ =
   let f stmt =
     match stmt with
     | Stmt.Fixed.Pattern.For {loopvar; lower; upper; body} -> (
@@ -460,7 +522,7 @@ let unroll_static_loops_statement =
 let static_loop_unrolling mir =
   transform_program_blockwise mir unroll_static_loops_statement
 
-let unroll_loop_one_step_statement =
+let unroll_loop_one_step_statement _ =
   let f stmt =
     match stmt with
     | Stmt.Fixed.Pattern.For {loopvar; lower; upper; body} ->
@@ -468,24 +530,27 @@ let unroll_loop_one_step_statement =
         else
           IfElse
             ( Expr.Fixed.
-                {lower with pattern= FunApp (StanLib, "Leq__", [lower; upper])}
+                {lower with pattern= FunApp (StanLib, "Geq__", [upper; lower])}
             , { pattern=
-                  Block
-                    [ subst_args_stmt [loopvar] [lower]
-                        {pattern= body.pattern; meta= Location_span.empty}
-                    ; { body with
-                        pattern=
-                          For
-                            { loopvar
-                            ; lower=
-                                { lower with
-                                  pattern=
-                                    FunApp
-                                      ( StanLib
-                                      , "Plus__"
-                                      , [lower; Expr.Helpers.loop_bottom] ) }
-                            ; upper
-                            ; body } } ]
+                  (let body_unrolled =
+                     subst_args_stmt [loopvar] [lower]
+                       {pattern= body.pattern; meta= Location_span.empty}
+                   in
+                   let (body' : Stmt.Located.t) =
+                     { pattern=
+                         Stmt.Fixed.Pattern.For { loopvar; upper; body;
+                                                  lower=
+                                                    { lower with
+                                                      pattern=
+                                                        FunApp
+                                                          ( StanLib
+                                                          , "Plus__"
+                                                          , [lower; Expr.Helpers.loop_bottom] ) } }
+                     ; meta= Location_span.empty }
+                   in
+                   match body_unrolled.pattern with
+                   | Block stmts -> Block (stmts @ [body'])
+                   | _ -> Stmt.Fixed.Pattern.Block [body_unrolled; body'])
               ; meta= Location_span.empty }
             , None )
     | While (e, body) ->
@@ -503,7 +568,7 @@ let unroll_loop_one_step_statement =
 let one_step_loop_unrolling mir =
   transform_program_blockwise mir unroll_loop_one_step_statement
 
-let collapse_lists_statement =
+let collapse_lists_statement _ =
   let rec collapse_lists l =
     match l with
     | [] -> []
@@ -551,31 +616,51 @@ let propagation
 let constant_propagation =
   propagation Monotone_framework.constant_propagation_transfer
 
-let rec can_side_effect_expr (e : Expr.Typed.t) =
+let rec expr_any pred (e : Expr.Typed.t) =
   match e.pattern with
-  | Var _ | Lit (_, _) -> false
-  | FunApp (t, f, es) ->
+  | Indexed (e, is) ->
+    expr_any pred e || List.exists ~f:(idx_any pred) is
+  | _ ->
+    pred e || Expr.Fixed.Pattern.fold (accum_any pred) false e.pattern
+and idx_any pred (i : Expr.Typed.t Index.t) =
+  Index.fold (accum_any pred) false i
+and accum_any pred b e = b || expr_any pred e
+
+let can_side_effect_top_expr (e : Expr.Typed.t) =
+  match e.pattern with
+  | FunApp (t, f, _) ->
       String.suffix f 3 = "_lp"
-      || List.exists ~f:can_side_effect_expr es
       || (t = CompilerInternal && f = Internal_fun.to_string FnReadParam)
+      || (t = CompilerInternal && f = Internal_fun.to_string FnReadData)
       || (t = CompilerInternal && f = Internal_fun.to_string FnWriteParam)
+      || (t = CompilerInternal && f = Internal_fun.to_string FnConstrain)
+      || (t = CompilerInternal && f = Internal_fun.to_string FnValidateSize)
+      || (t = CompilerInternal && f = Internal_fun.to_string FnValidateSize)
+      || (t = CompilerInternal && f = Internal_fun.to_string FnValidateSizeSimplex)
+      || (t = CompilerInternal && f = Internal_fun.to_string FnValidateSizeUnitVector)
       || (t = CompilerInternal && f = Internal_fun.to_string FnUnconstrain)
-  | TernaryIf (e1, e2, e3) -> List.exists ~f:can_side_effect_expr [e1; e2; e3]
-  | Indexed (e, is) ->
-      can_side_effect_expr e || List.exists ~f:can_side_effect_idx is
-  | EAnd (e1, e2) | EOr (e1, e2) -> List.exists ~f:can_side_effect_expr [e1; e2]
+  | _ -> false
 
-and can_side_effect_idx (i : Expr.Typed.t Index.t) =
-  match i with
-  | All -> false
-  | Single e | Upfrom e | MultiIndex e -> can_side_effect_expr e
-  | Between (e1, e2) -> can_side_effect_expr e1 || can_side_effect_expr e2
+let cannot_duplicate_expr (e : Expr.Typed.t) =
+  let pred e = can_side_effect_top_expr e || (
+      match e.pattern with
+      | FunApp (_, f, _) ->
+        String.suffix f 4 = "_rng"
+      | _ -> false
+    ) || (preserve_stability && UnsizedType.is_autodiffable e.meta.type_)
+  in expr_any pred e
+
+let cannot_remove_expr (e : Expr.Typed.t) =
+  expr_any can_side_effect_top_expr e
 
-let expression_propagation =
+let expression_propagation mir =
   propagation
-    (Monotone_framework.expression_propagation_transfer can_side_effect_expr)
+    (Monotone_framework.expression_propagation_transfer cannot_duplicate_expr)
+    mir
 
-let copy_propagation = propagation Monotone_framework.copy_propagation_transfer
+let copy_propagation mir =
+  let globals = Monotone_framework.globals mir in
+  propagation (Monotone_framework.copy_propagation_transfer globals) mir
 
 let is_skip_break_continue s =
   match s with
@@ -606,14 +691,15 @@ let dead_code_elimination (mir : Program.Typed.t) =
       in
       match stmt with
       | Stmt.Fixed.Pattern.Assignment ((x, _, []), rhs) ->
-          if Set.Poly.mem live_variables_s x || can_side_effect_expr rhs then
+          if Set.Poly.mem live_variables_s x || cannot_remove_expr rhs then
             stmt
-          else Skip
+          else
+            Skip
       | Assignment ((x, _, is), rhs) ->
           if
             Set.Poly.mem live_variables_s x
-            || can_side_effect_expr rhs
-            || List.exists ~f:can_side_effect_idx is
+            || cannot_remove_expr rhs
+            || List.exists ~f:(idx_any cannot_remove_expr) is
           then stmt
           else Skip
       (* NOTE: we never get rid of declarations as we might not be able to
@@ -627,7 +713,7 @@ let dead_code_elimination (mir : Program.Typed.t) =
       | IfElse (e, b1, b2) -> (
           if
             (* TODO: check if e has side effects, like print, reject, then don't optimize? *)
-            (not (can_side_effect_expr e))
+            (not (cannot_remove_expr e))
             && b1.Stmt.Fixed.pattern = Skip
             && ( Option.map ~f:(fun Stmt.Fixed.({pattern; _}) -> pattern) b2
                  = Some Skip
@@ -641,15 +727,15 @@ let dead_code_elimination (mir : Program.Typed.t) =
             | Lit (_, _) -> b1.pattern
             | _ -> IfElse (e, b1, b2) )
       | While (e, b) -> (
-          if (not (can_side_effect_expr e)) && b.pattern = Break then Skip
+          if (not (cannot_remove_expr e)) && b.pattern = Break then Skip
           else
             match e.pattern with
             | Lit (Int, "0") | Lit (Real, "0.0") -> Skip
             | _ -> While (e, b) )
       | For {loopvar; lower; upper; body} ->
           if
-            (not (can_side_effect_expr lower))
-            && (not (can_side_effect_expr upper))
+            (not (cannot_remove_expr lower))
+            && (not (cannot_remove_expr upper))
             && is_skip_break_continue body.pattern
           then Skip
           else For {loopvar; lower; upper; body}
@@ -713,7 +799,7 @@ let lazy_code_motion (mir : Program.Typed.t) =
   in
   let transform s =
     let rev_flowgraph, flowgraph_to_mir =
-      Monotone_framework.inverse_flowgraph_of_stmt s
+      Monotone_framework.inverse_flowgraph_of_stmt ~blocks_after_body:false s
     in
     let fwd_flowgraph = Monotone_framework.reverse rev_flowgraph in
     let latest_expr, used_not_latest_expressions_mfp =
@@ -721,12 +807,17 @@ let lazy_code_motion (mir : Program.Typed.t) =
         flowgraph_to_mir
     in
     let expression_map =
+      let rec collect_expressions accum (e : Expr.Typed.t) =
+        match e.pattern with
+        | Lit (_, _) -> accum
+        | Var _ -> accum
+        | _ when cannot_duplicate_expr e ->
+          (* Immovable expressions might have movable subexpressions *)
+          Expr.Fixed.Pattern.fold collect_expressions accum e.pattern
+        | _ -> Map.set accum ~key:e ~data:(Gensym.generate ~prefix:"lcm_" ())
+      in
       Set.fold (Monotone_framework.used_expressions_stmt s.pattern)
-        ~init:Expr.Typed.Map.empty ~f:(fun accum e ->
-          match e.pattern with
-          | Lit (_, _) -> accum
-          | _ when can_side_effect_expr e -> accum
-          | _ -> Map.set accum ~key:e ~data:(Gensym.generate ()) )
+        ~init:Expr.Typed.Map.empty ~f:collect_expressions
     in
     (* TODO: it'd be more efficient to just not accumulate constants in the static analysis *)
     let declarations_list =
@@ -747,15 +838,12 @@ let lazy_code_motion (mir : Program.Typed.t) =
           (Map.find_exn used_not_latest_expressions_mfp i).entry
       in
       let to_assign_in_s =
-        Set.filter
-          ~f:(fun x -> Map.mem expression_map x)
-          latest_and_used_after_i
-      in
-      let to_assign_in_s = Set.to_list to_assign_in_s in
-      let to_assign_in_s =
-        List.sort
-          ~compare:(fun e e' -> compare_int (expr_depth e) (expr_depth e'))
-          to_assign_in_s
+        latest_and_used_after_i
+        |> Set.filter ~f:(fun x ->
+            Map.mem expression_map x)
+        |> Set.to_list
+        |> List.sort ~compare:(fun e e' ->
+            compare_int (expr_depth e) (expr_depth e'))
       in
       (* TODO: is this sort doing anything or are they already stored in the right order by
          chance? It appears to not do anything. *)
@@ -781,15 +869,17 @@ let lazy_code_motion (mir : Program.Typed.t) =
         in
         map_rec_stmt_loc f
       in
+      let expr_map =
+        Map.filter_keys
+          ~f:(fun key ->
+              Set.mem latest_and_used_after_i key
+              || Set.mem (Map.find_exn used_not_latest_expressions_mfp i).exit
+                key )
+          (Map.mapi expression_map ~f:(fun ~key ~data ->
+               {key with pattern= Var data} ))
+      in
       let f =
-        expr_subst_stmt_except_initial_assign
-          (Map.filter_keys
-             ~f:(fun key ->
-               Set.mem latest_and_used_after_i key
-               || Set.mem (Map.find_exn used_not_latest_expressions_mfp i).exit
-                    key )
-             (Map.mapi expression_map ~f:(fun ~key ~data ->
-                  {key with pattern= Var data} )))
+        expr_subst_stmt_except_initial_assign expr_map
       in
       if List.length assignments_to_add_to_s = 0 then
         (f Stmt.Fixed.{pattern= stmt; meta= Location_span.empty}).pattern
@@ -809,11 +899,36 @@ let lazy_code_motion (mir : Program.Typed.t) =
             @ [lazy_code_motion_stmt (Map.find_exn flowgraph_to_mir 1)] )
       ; meta= Location_span.empty }
   in
-  transform_program_blockwise mir (fun x -> transform (preprocess_flowgraph x))
+  let cleanup =
+    let cleanup_base
+        (stmt : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t) : (Expr.Typed.t, Stmt.Located.t) Stmt.Fixed.Pattern.t =
+      match stmt with
+      | Stmt.Fixed.(
+            Pattern.IfElse
+              ( e
+              , { pattern= Block [b1; {pattern= Skip; _}] ; _}
+              , Some { pattern= Block [b2; {pattern= Skip; _}] ; _} ))
+        -> IfElse (e, b1, Some b2)
+      | IfElse ( e
+               , { pattern= Block [b; {pattern= Skip; _}] ; _}
+               , Some {pattern= Skip; _} )
+        -> IfElse (e, b, None)
+      | While (e , { pattern= Block [b; {pattern= Skip; _}] ; _})
+        -> While (e, b)
+      | For
+          { loopvar ; lower ; upper ; body=
+              { pattern= Block [b; {pattern= Skip; _}] ; _} }
+        -> For {loopvar; lower; upper; body= b}
+      | _ -> stmt
+    in
+    map_rec_stmt_loc cleanup_base
+  in
+  transform_program_blockwise mir (fun _ x -> cleanup (transform (preprocess_flowgraph x)))
 
 let block_fixing mir =
   transform_program_blockwise mir
-    (map_rec_stmt_loc (fun stmt ->
+    (fun _ x ->
+       (map_rec_stmt_loc (fun stmt ->
          match stmt with
          | IfElse
              ( e
@@ -832,6 +947,7 @@ let block_fixing mir =
          | For {loopvar; lower; upper; body= {pattern= SList l; meta}} ->
              For {loopvar; lower; upper; body= {pattern= Block l; meta}}
          | _ -> stmt ))
+         x)
 
 (* TODO: implement SlicStan style optimizer for choosing best program block for each statement. *)
 (* TODO: add optimization pass to move declarations down as much as possible and introduce as
@@ -840,7 +956,14 @@ let block_fixing mir =
 (* TODO: add pass to get rid of redundant declarations? *)
 
 let optimize_ad_levels (mir : Program.Typed.t) =
-  let transform s =
+  let global_initial_ad_variables =
+    Set.Poly.of_list
+      (List.filter_map
+         ~f:(fun (v, Program.({out_block; _})) ->
+             match out_block with Parameters -> Some v | _ -> None )
+         mir.output_vars)
+  in
+  let transform fundef_opt s =
     let rev_flowgraph, flowgraph_to_mir =
       Monotone_framework.inverse_flowgraph_of_stmt s
     in
@@ -848,11 +971,18 @@ let optimize_ad_levels (mir : Program.Typed.t) =
     let (module Rev_Flowgraph) = rev_flowgraph in
     let (module Fwd_Flowgraph) = fwd_flowgraph in
     let initial_ad_variables =
-      Set.Poly.of_list
-        (List.filter_map
-           ~f:(fun (v, Program.({out_block; _})) ->
-             match out_block with Parameters -> Some v | _ -> None )
-           mir.output_vars)
+      match (fundef_opt : Stmt.Located.t Program.fun_def option) with
+      | None -> global_initial_ad_variables
+      | Some {fdargs; _} ->
+        Set.Poly.union global_initial_ad_variables
+          (Set.Poly.of_list
+             (List.filter_map fdargs
+                ~f:(fun (_, name, ut) ->
+                    if UnsizedType.is_autodiffable ut then
+                      Some name
+                    else
+                      None
+                  )))
     in
     let ad_levels =
       Monotone_framework.autodiff_level_mfp
@@ -904,7 +1034,27 @@ type optimization_settings =
   ; lazy_code_motion: bool
   ; optimize_ad_levels: bool }
 
-let optimization_suite settings mir =
+let const_optimizations b : optimization_settings =
+  { function_inlining= b
+  ; static_loop_unrolling= b
+  ; one_step_loop_unrolling= b
+  ; list_collapsing= b
+  ; block_fixing= b
+  ; constant_propagation= b
+  ; expression_propagation= b
+  ; copy_propagation= b
+  ; dead_code_elimination= b
+  ; partial_evaluation= b
+  ; lazy_code_motion= b
+  ; optimize_ad_levels= b }
+
+let all_optimizations : optimization_settings =
+  const_optimizations true
+
+let no_optimizations : optimization_settings =
+  const_optimizations false
+
+let optimization_suite ?settings:(settings=all_optimizations) mir =
   let maybe_optimizations =
     [ (* Phase order. See phase-ordering-nodes.org for details *)
       (* Book section A *)
diff --git a/src/analysis_and_optimization/Optimize.mli b/src/analysis_and_optimization/Optimize.mli
index 88aeaf1922..5dbea5dd9c 100644
--- a/src/analysis_and_optimization/Optimize.mli
+++ b/src/analysis_and_optimization/Optimize.mli
@@ -70,6 +70,10 @@ type optimization_settings =
   ; lazy_code_motion: bool
   ; optimize_ad_levels: bool }
 
+val all_optimizations : optimization_settings
+
+val no_optimizations : optimization_settings
+
 val optimization_suite :
-  optimization_settings -> Program.Typed.t -> Program.Typed.t
+  ?settings:optimization_settings -> Program.Typed.t -> Program.Typed.t
 (** Perform all optimizations in this module on the MIR in an appropriate order. *)
diff --git a/src/analysis_and_optimization/Partial_evaluator.ml b/src/analysis_and_optimization/Partial_evaluator.ml
index db85f9640f..a9d95d8eda 100644
--- a/src/analysis_and_optimization/Partial_evaluator.ml
+++ b/src/analysis_and_optimization/Partial_evaluator.ml
@@ -4,6 +4,8 @@ open Core_kernel
 open Mir_utils
 open Middle
 
+let preserve_stability = false
+
 let is_int i Expr.Fixed.({pattern; _}) =
   let nums = List.map ~f:(fun s -> string_of_int i ^ s) [""; "."; ".0"] in
   match pattern with
@@ -216,7 +218,7 @@ let rec eval_expr (e : Expr.Typed.t) =
                         , "Minus__"
                         , [y; {pattern= FunApp (StanLib, "exp", [x]); _}] ); _
                   } ] )
-              when is_int 1 y ->
+              when is_int 1 y && not preserve_stability ->
                 FunApp (StanLib, "log1m_exp", [x])
             | ( "log"
               , [ { pattern=
@@ -225,10 +227,10 @@ let rec eval_expr (e : Expr.Typed.t) =
                         , "Minus__"
                         , [y; {pattern= FunApp (StanLib, "inv_logit", [x]); _}]
                         ); _ } ] )
-              when is_int 1 y ->
+              when is_int 1 y && not preserve_stability ->
                 FunApp (StanLib, "log1m_inv_logit", [x])
             | "log", [{pattern= FunApp (StanLib, "Minus__", [y; x]); _}]
-              when is_int 1 y ->
+              when is_int 1 y && not preserve_stability ->
                 FunApp (StanLib, "log1m", [x])
             | ( "log"
               , [ { pattern=
@@ -237,10 +239,10 @@ let rec eval_expr (e : Expr.Typed.t) =
                         , "Plus__"
                         , [y; {pattern= FunApp (StanLib, "exp", [x]); _}] ); _
                   } ] )
-              when is_int 1 y ->
+              when is_int 1 y && not preserve_stability ->
                 FunApp (StanLib, "log1p_exp", [x])
             | "log", [{pattern= FunApp (StanLib, "Plus__", [y; x]); _}]
-              when is_int 1 y ->
+              when is_int 1 y && not preserve_stability ->
                 FunApp (StanLib, "log1p", [x])
             | ( "log"
               , [ { pattern=
@@ -552,11 +554,11 @@ let rec eval_expr (e : Expr.Typed.t) =
               when is_int 1 x ->
                 FunApp (StanLib, "erf", l)
             | "Minus__", [{pattern= FunApp (StanLib, "exp", l'); _}; x]
-              when is_int 1 x ->
+              when is_int 1 x && not preserve_stability ->
                 FunApp (StanLib, "expm1", l')
             | "Plus__", [{pattern= FunApp (StanLib, "Times__", [x; y]); _}; z]
              |"Plus__", [z; {pattern= FunApp (StanLib, "Times__", [x; y]); _}]
-              ->
+               when not preserve_stability ->
                 FunApp (StanLib, "fma", [x; y; z])
             | "Minus__", [x; {pattern= FunApp (StanLib, "gamma_p", l); _}]
               when is_int 1 x ->
@@ -590,7 +592,8 @@ let rec eval_expr (e : Expr.Typed.t) =
               ->
                 FunApp (StanLib, "matrix_exp_multiply", [a; b])
             | "Times__", [x; {pattern= FunApp (StanLib, "log", [y]); _}]
-             |"Times__", [{pattern= FunApp (StanLib, "log", [y]); _}; x] ->
+             |"Times__", [{pattern= FunApp (StanLib, "log", [y]); _}; x]
+               when not preserve_stability ->
                 FunApp (StanLib, "lmultiply", [x; y])
             | ( "Times__"
               , [ {pattern= FunApp (StanLib, "diag_matrix", [v]); _}
diff --git a/src/common/Gensym.ml b/src/common/Gensym.ml
index 81d9ddf250..5d6268762d 100644
--- a/src/common/Gensym.ml
+++ b/src/common/Gensym.ml
@@ -1,8 +1,8 @@
 let _counter = ref 0
 
-let generate () =
+let generate ?prefix:(prefix : string = "") () =
   _counter := !_counter + 1 ;
-  Format.sprintf "sym%d__" !_counter
+  Format.sprintf "%ssym%d__" prefix !_counter
 
 let enter () =
   let old_counter = !_counter in
diff --git a/src/common/Gensym.mli b/src/common/Gensym.mli
index 8aac141a48..20e58566ba 100644
--- a/src/common/Gensym.mli
+++ b/src/common/Gensym.mli
@@ -1,3 +1,3 @@
-val generate : unit -> string
+val generate : ?prefix:string -> unit -> string
 val enter : unit -> string * (unit -> unit)
 val reset_danger_use_cautiously : unit -> unit
diff --git a/src/middle/UnsizedType.ml b/src/middle/UnsizedType.ml
index f2e032338a..48eb0229a9 100644
--- a/src/middle/UnsizedType.ml
+++ b/src/middle/UnsizedType.ml
@@ -105,6 +105,13 @@ let is_real_type = function
       true
   | _ -> false
 
+let rec is_autodiffable = function
+  | UReal | UVector | URowVector | UMatrix ->
+    true
+  |UArray t ->
+    is_autodiffable t
+  | _ -> false
+
 let is_scalar_type = function UReal | UInt -> true | _ -> false
 let is_int_type = function UInt | UArray UInt -> true | _ -> false
 let is_fun_type = function UFun _ -> true | _ -> false
diff --git a/src/stan_math_backend/Stan_math_code_gen.ml b/src/stan_math_backend/Stan_math_code_gen.ml
index b0cab6087a..222f4f2242 100644
--- a/src/stan_math_backend/Stan_math_code_gen.ml
+++ b/src/stan_math_backend/Stan_math_code_gen.ml
@@ -327,15 +327,20 @@ let pp_ctor ppf p =
             , List.filter_map ~f:get_param_st output_vars ) ) )
     , p )
 
+let rec top_level_decls Stmt.Fixed.({pattern; _}) =
+  match pattern with
+  | Decl d ->
+    [Some (d.decl_id, Type.to_unsized d.decl_type, UnsizedType.DataOnly)]
+  | SList stmts ->
+    List.concat_map ~f:top_level_decls stmts
+  | _ -> [None]
+
 (** Print the private data members of the model class *)
 let pp_model_private ppf {Program.prepare_data; _} =
-  let decl Stmt.Fixed.({pattern; _}) =
-    match pattern with
-    | Decl d ->
-        Some (d.decl_id, Type.to_unsized d.decl_type, UnsizedType.DataOnly)
-    | _ -> None
+  let data_decls =
+    List.concat_map ~f:top_level_decls prepare_data
+    |> List.filter_map ~f:ident
   in
-  let data_decls = List.filter_map ~f:decl prepare_data in
   pf ppf "%a" (list ~sep:cut pp_decl) data_decls
 
 (** Print the signature and blocks of the model class methods.
diff --git a/src/stanc/stanc.ml b/src/stanc/stanc.ml
index 428b265f0a..d1752dff09 100644
--- a/src/stanc/stanc.ml
+++ b/src/stanc/stanc.ml
@@ -99,8 +99,8 @@ let options =
          \"$model_filename_model\")" )
     ; ( "--O"
       , Arg.Set optimize
-      , " Allow the compiler to apply all optimizations to the Stan \
-         code.WARNING: This is currently an experimental feature!" )
+      , "Allow the compiler to apply all optimizations to the Stan \
+         code." )
     ; ( "--o"
       , Arg.Set_string output_file
       , " Take the path to an output file for generated C++ code (default = \
@@ -122,22 +122,6 @@ let options =
       , Arg.Set Transform_Mir.use_opencl
       , " If set, try to use matrix_cl signatures." ) ]
 
-(* Whether or not to run each optimization. Currently it's all or nothing
-   depending on the --O flag.*)
-let optimization_settings () : Optimize.optimization_settings =
-  { function_inlining= !optimize
-  ; static_loop_unrolling= !optimize
-  ; one_step_loop_unrolling= !optimize
-  ; list_collapsing= !optimize
-  ; block_fixing= !optimize
-  ; constant_propagation= !optimize
-  ; expression_propagation= !optimize
-  ; copy_propagation= !optimize
-  ; dead_code_elimination= !optimize
-  ; partial_evaluation= !optimize
-  ; lazy_code_motion= !optimize
-  ; optimize_ad_levels= true }
-
 let print_warn_uninitialized
     (uninit_vars : (Location_span.t * string) Set.Poly.t) =
   let show_location_span Location_span.({begin_loc; end_loc; _}) =
@@ -214,7 +198,7 @@ let use_file filename =
     let opt_mir =
       if !optimize then (
         let opt =
-          Optimize.optimization_suite (optimization_settings ()) tx_mir
+          Optimize.optimization_suite tx_mir
         in
         if !dump_opt_mir then
           Sexp.pp_hum Format.std_formatter
diff --git a/test/integration/good/compiler-optimizations/ad-level-failing.stan b/test/integration/good/compiler-optimizations/ad-level-failing.stan
new file mode 100644
index 0000000000..0a2d47734d
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/ad-level-failing.stan
@@ -0,0 +1,71 @@
+// Simple SIR model inspired by the presentation in
+// http://www.ncbi.nlm.nih.gov/pmc/articles/PMC3380087/pdf/nihms372789.pdf
+
+functions {
+  
+  // theta[1] = beta, water contact rate
+  // theta[2] = kappa, C_{50}
+  // theta[3] = gamma, recovery rate
+  // theta[4] = xi, bacteria production rate
+  // theta[5] = delta, bacteria removal rate
+  real[] simple_SIR(real t,
+                    real[] y,
+                    real[] theta,
+                    real[] x_r,
+                    int[] x_i) {
+
+    real dydt[4];
+
+    dydt[1] = - theta[1] * y[4] / (y[4] + theta[2]) * y[1];
+    dydt[2] = theta[1] * y[4] / (y[4] + theta[2]) * y[1] - theta[3] * y[2];
+    dydt[3] = theta[3] * y[2];
+    dydt[4] = theta[4] * y[2] - theta[5] * y[4];
+
+    return dydt;
+  }
+}
+
+data {
+  int<lower=0> N_t;
+  real t[N_t];
+  real y0[4];
+  int stoi_hat[N_t];
+  real B_hat[N_t];
+}
+
+transformed data {
+  real t0 = 0;
+  real<lower=0> kappa = 1000000;
+
+  real x_r[0];
+  int x_i[0];
+}
+
+parameters {
+  real<lower=0> beta;
+  real<lower=0> gamma;
+  real<lower=0> xi;
+  real<lower=0> delta;
+}
+
+transformed parameters {
+  real<lower=0> y[N_t, 4];
+  {
+    real theta[5] = {beta, kappa, gamma, xi, delta};
+    y = integrate_ode_rk45(simple_SIR, y0, t0, t, theta, x_r, x_i);
+  }
+}
+  
+model {
+  beta ~ cauchy(0, 2.5);
+  gamma ~ cauchy(0, 1);
+  xi ~ cauchy(0, 25);
+  delta ~ cauchy(0, 1);
+
+  stoi_hat[1] ~ poisson(y0[1] - y[1, 1]);
+  for (n in 2:N_t)
+    stoi_hat[n] ~ poisson(y[n - 1, 1] - y[n, 1]);
+
+  B_hat ~ lognormal(log(col(to_matrix(y), 4)), 0.15);
+  
+}
diff --git a/test/integration/good/compiler-optimizations/copy_fail.stan b/test/integration/good/compiler-optimizations/copy_fail.stan
new file mode 100644
index 0000000000..a8742e5b37
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/copy_fail.stan
@@ -0,0 +1,111 @@
+// This models is derived from section 12.3 of "Stan Modeling Language
+// User's Guide and Reference Manual"
+
+functions {
+  int first_capture(int[] y_i) {
+    for (k in 1:size(y_i))
+      if (y_i[k])
+        return k;
+    return 0;
+  }
+
+  int last_capture(int[] y_i) {
+    for (k_rev in 0:(size(y_i) - 1)) {
+      // Compoud declaration was enabled in Stan 2.13
+      int k = size(y_i) - k_rev;
+      //      int k;
+      //      k = size(y_i) - k_rev;
+      if (y_i[k])
+        return k;
+    }
+    return 0;
+  }
+
+  matrix prob_uncaptured(int nind, int n_occasions,
+                         matrix p, matrix phi) {
+    matrix[nind, n_occasions] chi;
+
+    for (i in 1:nind) {
+      chi[i, n_occasions] = 1.0;
+      for (t in 1:(n_occasions - 1)) {
+        // Compoud declaration was enabled in Stan 2.13
+        int t_curr = n_occasions - t;
+        int t_next = t_curr + 1;
+        /*
+        int t_curr;
+        int t_next;
+
+        t_curr = n_occasions - t;
+        t_next = t_curr + 1;
+        */
+        chi[i, t_curr] = (1 - phi[i, t_curr])
+                        + phi[i, t_curr] * (1 - p[i, t_next - 1]) * chi[i, t_next];
+      }
+    }
+    return chi;
+  }
+}
+
+data {
+  int<lower=0> nind;            // Number of individuals
+  int<lower=2> n_occasions;     // Number of capture occasions
+  int<lower=0,upper=1> y[nind, n_occasions];    // Capture-history
+  int<lower=1> max_age;         // Maximum age
+  int<lower=0,upper=max_age> x[nind, n_occasions - 1];  // Age
+}
+
+transformed data {
+  int n_occ_minus_1 = n_occasions - 1;
+  //  int n_occ_minus_1;
+  int<lower=0,upper=n_occasions> first[nind];
+  int<lower=0,upper=n_occasions> last[nind];
+
+  //  n_occ_minus_1 = n_occasions - 1;
+  for (i in 1:nind)
+    first[i] = first_capture(y[i]);
+  for (i in 1:nind)
+    last[i] = last_capture(y[i]);
+}
+
+parameters {
+  real<lower=0,upper=1> mean_p;           // Mean recapture
+  vector<lower=0,upper=1>[max_age] beta;  // Mean survival
+}
+
+transformed parameters {
+  matrix<lower=0,upper=1>[nind, n_occ_minus_1] phi;   // Survival
+  matrix<lower=0,upper=1>[nind, n_occ_minus_1] p;     // Recapture
+  matrix<lower=0,upper=1>[nind, n_occasions] chi;
+
+  // Constraints
+  for (i in 1:nind) {
+    for (t in 1:(first[i] - 1)) {
+      phi[i, t] = 0;
+      p[i, t] = 0;
+    }
+    for (t in first[i]:n_occ_minus_1) {
+      phi[i, t] = beta[x[i, t]];
+      p[i, t] = mean_p;
+    }
+  }
+
+  chi = prob_uncaptured(nind, n_occasions, p, phi);
+}
+
+model {
+  // Priors
+  // Uniform priors are implicitly defined.
+  //  beta ~ uniform(0, 1);
+  //  mean_p ~ uniform(0, 1);
+
+  // Likelihood
+  for (i in 1:nind) {
+    if (first[i] > 0) {
+      for (t in (first[i] + 1):last[i]) {
+        1 ~ bernoulli(phi[i, t - 1]);
+        y[i, t] ~ bernoulli(p[i, t - 1]);
+      }
+      1 ~ bernoulli(chi[i, last[i]]);
+    }
+  }
+}
diff --git a/test/integration/good/compiler-optimizations/cpp.expected b/test/integration/good/compiler-optimizations/cpp.expected
index 83bdce422f..02b9915d68 100644
--- a/test/integration/good/compiler-optimizations/cpp.expected
+++ b/test/integration/good/compiler-optimizations/cpp.expected
@@ -1,8 +1,8 @@
-  $ ../../../../../install/default/bin/stanc --O --print-cpp optimizations.stan
+  $ ../../../../../install/default/bin/stanc --O --print-cpp ad-level-failing.stan
 
 // Code generated by %%NAME%% %%VERSION%%
 #include <stan/model/model_header.hpp>
-namespace optimizations_model_namespace {
+namespace ad_level_failing_model_namespace {
 
 template <typename T, typename S>
 std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
@@ -91,191 +91,94 @@ using namespace stan::math;
 
 static int current_statement__ = 0;
 static const std::vector<string> locations_array__ = {" (found before start of program)",
-                                                      " (in 'optimizations.stan', line 20, column 4 to column 15)",
-                                                      " (in 'optimizations.stan', line 21, column 4 to column 13)",
-                                                      " (in 'optimizations.stan', line 22, column 4 to column 26)",
-                                                      " (in 'optimizations.stan', line 23, column 4 to column 23)",
-                                                      " (in 'optimizations.stan', line 24, column 4 to column 24)",
-                                                      " (in 'optimizations.stan', line 27, column 4 to column 11)",
-                                                      " (in 'optimizations.stan', line 5, column 8 to column 20)",
-                                                      " (in 'optimizations.stan', line 2, column 33 to line 6, column 5)",
-                                                      " (in 'optimizations.stan', line 28, column 4 to column 19)",
-                                                      " (in 'optimizations.stan', line 10, column 12 to column 26)",
-                                                      " (in 'optimizations.stan', line 9, column 8 to line 10, column 26)",
-                                                      " (in 'optimizations.stan', line 8, column 20 to line 12, column 5)",
-                                                      " (in 'optimizations.stan', line 30, column 17 to column 28)",
-                                                      " (in 'optimizations.stan', line 33, column 6 to column 22)",
-                                                      " (in 'optimizations.stan', line 31, column 33 to line 34, column 5)",
-                                                      " (in 'optimizations.stan', line 36, column 8 to column 21)",
-                                                      " (in 'optimizations.stan', line 35, column 21 to line 37, column 5)",
-                                                      " (in 'optimizations.stan', line 35, column 4 to line 37, column 5)",
-                                                      " (in 'optimizations.stan', line 41, column 16 to column 29)",
-                                                      " (in 'optimizations.stan', line 40, column 12 to line 41, column 29)",
-                                                      " (in 'optimizations.stan', line 39, column 8 to line 41, column 29)",
-                                                      " (in 'optimizations.stan', line 38, column 4 to line 41, column 29)",
-                                                      " (in 'optimizations.stan', line 44, column 10 to column 16)",
-                                                      " (in 'optimizations.stan', line 43, column 8 to line 44, column 16)",
-                                                      " (in 'optimizations.stan', line 45, column 8 to column 20)",
-                                                      " (in 'optimizations.stan', line 42, column 21 to line 46, column 5)",
-                                                      " (in 'optimizations.stan', line 42, column 4 to line 46, column 5)",
-                                                      " (in 'optimizations.stan', line 49, column 10 to column 19)",
-                                                      " (in 'optimizations.stan', line 48, column 8 to line 49, column 19)",
-                                                      " (in 'optimizations.stan', line 50, column 8 to column 20)",
-                                                      " (in 'optimizations.stan', line 47, column 21 to line 51, column 5)",
-                                                      " (in 'optimizations.stan', line 47, column 4 to line 51, column 5)",
-                                                      " (in 'optimizations.stan', line 54, column 10 to column 19)",
-                                                      " (in 'optimizations.stan', line 53, column 8 to line 54, column 19)",
-                                                      " (in 'optimizations.stan', line 55, column 8 to column 20)",
-                                                      " (in 'optimizations.stan', line 52, column 21 to line 56, column 5)",
-                                                      " (in 'optimizations.stan', line 52, column 4 to line 56, column 5)",
-                                                      " (in 'optimizations.stan', line 58, column 4 to column 16)",
-                                                      " (in 'optimizations.stan', line 61, column 4 to column 16)",
-                                                      " (in 'optimizations.stan', line 64, column 4 to column 16)",
-                                                      " (in 'optimizations.stan', line 66, column 4 to column 16)",
-                                                      " (in 'optimizations.stan', line 69, column 4 to column 16)",
-                                                      " (in 'optimizations.stan', line 70, column 4 to column 11)",
-                                                      " (in 'optimizations.stan', line 72, column 4 to column 16)",
-                                                      " (in 'optimizations.stan', line 75, column 4 to column 16)",
-                                                      " (in 'optimizations.stan', line 78, column 4 to column 16)",
-                                                      " (in 'optimizations.stan', line 80, column 8 to column 19)",
-                                                      " (in 'optimizations.stan', line 82, column 8 to column 20)",
-                                                      " (in 'optimizations.stan', line 79, column 4 to line 83, column 5)",
-                                                      " (in 'optimizations.stan', line 85, column 8 to column 20)",
-                                                      " (in 'optimizations.stan', line 87, column 8 to column 20)",
-                                                      " (in 'optimizations.stan', line 84, column 4 to line 88, column 5)",
-                                                      " (in 'optimizations.stan', line 90, column 11 to column 23)",
-                                                      " (in 'optimizations.stan', line 90, column 4 to column 23)",
-                                                      " (in 'optimizations.stan', line 15, column 8 to column 20)",
-                                                      " (in 'optimizations.stan', line 14, column 18 to line 17, column 5)",
-                                                      " (in 'optimizations.stan', line 97, column 20 to column 26)",
-                                                      " (in 'optimizations.stan', line 97, column 4 to column 26)",
-                                                      " (in 'optimizations.stan', line 98, column 22 to column 28)",
-                                                      " (in 'optimizations.stan', line 100, column 6 to column 15)",
-                                                      " (in 'optimizations.stan', line 99, column 4 to line 100, column 15)",
-                                                      " (in 'optimizations.stan', line 102, column 6 to column 12)",
-                                                      " (in 'optimizations.stan', line 101, column 4 to line 102, column 12)",
-                                                      " (in 'optimizations.stan', line 106, column 6 to column 15)",
-                                                      " (in 'optimizations.stan', line 108, column 6 to column 12)",
-                                                      " (in 'optimizations.stan', line 112, column 8 to column 20)",
-                                                      " (in 'optimizations.stan', line 115, column 8 to column 21)",
-                                                      " (in 'optimizations.stan', line 111, column 4 to line 116, column 5)",
-                                                      " (in 'optimizations.stan', line 119, column 12 to column 24)",
-                                                      " (in 'optimizations.stan', line 118, column 8 to line 121, column 9)",
-                                                      " (in 'optimizations.stan', line 117, column 4 to line 127, column 5)",
-                                                      " (in 'optimizations.stan', line 128, column 4 to column 14)",
-                                                      " (in 'optimizations.stan', line 132, column 6 to column 21)",
-                                                      " (in 'optimizations.stan', line 129, column 4 to line 132, column 21)",
-                                                      " (in 'optimizations.stan', line 134, column 4 to column 15)",
-                                                      " (in 'optimizations.stan', line 137, column 8 to column 23)",
-                                                      " (in 'optimizations.stan', line 138, column 8 to column 24)",
-                                                      " (in 'optimizations.stan', line 135, column 21 to line 139, column 5)",
-                                                      " (in 'optimizations.stan', line 135, column 4 to line 139, column 5)",
-                                                      " (in 'optimizations.stan', line 140, column 4 to column 25)",
-                                                      " (in 'optimizations.stan', line 143, column 4 to column 26)",
-                                                      " (in 'optimizations.stan', line 144, column 4 to column 22)",
-                                                      " (in 'optimizations.stan', line 146, column 6 to column 28)",
-                                                      " (in 'optimizations.stan', line 145, column 4 to line 146, column 28)",
-                                                      " (in 'optimizations.stan', line 147, column 4 to column 23)",
-                                                      " (in 'optimizations.stan', line 4, column 10 to column 17)",
-                                                      " (in 'optimizations.stan', line 3, column 8 to line 4, column 17)",
-                                                      " (in 'optimizations.stan', line 11, column 8 to column 21)",
-                                                      " (in 'optimizations.stan', line 16, column 8 to column 18)"};
-
-
-template <bool propto__, typename T0__, typename T_lp__,
-typename T_lp_accum__>
-void
-nrfun_lp(const T0__& x, const int& y, T_lp__& lp__, T_lp_accum__& lp_accum__,
-         std::ostream* pstream__) {
-  using local_scalar_t__ = stan::promote_args_t<T0__>;
-  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
-  (void) DUMMY_VAR__;  // suppress unused var warning
-  
-  try {
-    int sym34__;
-    int sym33__;
-    {
-      current_statement__ = 87;
-      if (logical_gt(x, 342)) {
-        {
-          current_statement__ = 86;
-          return ;
-        }
-      } else ;
-      current_statement__ = 7;
-      lp_accum__.add(y);
-    }
-  } catch (const std::exception& e) {
-    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
-      // Next line prevents compiler griping about no return
-      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
-  }
-  
-}
+                                                      " (in 'ad-level-failing.stan', line 45, column 2 to column 21)",
+                                                      " (in 'ad-level-failing.stan', line 46, column 2 to column 22)",
+                                                      " (in 'ad-level-failing.stan', line 47, column 2 to column 19)",
+                                                      " (in 'ad-level-failing.stan', line 48, column 2 to column 22)",
+                                                      " (in 'ad-level-failing.stan', line 52, column 2 to column 26)",
+                                                      " (in 'ad-level-failing.stan', line 54, column 4 to column 52)",
+                                                      " (in 'ad-level-failing.stan', line 53, column 2 to line 56, column 3)",
+                                                      " (in 'ad-level-failing.stan', line 60, column 2 to column 24)",
+                                                      " (in 'ad-level-failing.stan', line 61, column 2 to column 23)",
+                                                      " (in 'ad-level-failing.stan', line 62, column 2 to column 21)",
+                                                      " (in 'ad-level-failing.stan', line 63, column 2 to column 23)",
+                                                      " (in 'ad-level-failing.stan', line 65, column 2 to column 41)",
+                                                      " (in 'ad-level-failing.stan', line 67, column 4 to column 49)",
+                                                      " (in 'ad-level-failing.stan', line 66, column 2 to line 67, column 49)",
+                                                      " (in 'ad-level-failing.stan', line 69, column 2 to column 53)",
+                                                      " (in 'ad-level-failing.stan', line 29, column 2 to column 19)",
+                                                      " (in 'ad-level-failing.stan', line 30, column 2 to column 14)",
+                                                      " (in 'ad-level-failing.stan', line 31, column 2 to column 13)",
+                                                      " (in 'ad-level-failing.stan', line 32, column 2 to column 20)",
+                                                      " (in 'ad-level-failing.stan', line 33, column 2 to column 18)",
+                                                      " (in 'ad-level-failing.stan', line 37, column 2 to column 14)",
+                                                      " (in 'ad-level-failing.stan', line 38, column 2 to column 32)",
+                                                      " (in 'ad-level-failing.stan', line 40, column 2 to column 14)",
+                                                      " (in 'ad-level-failing.stan', line 41, column 2 to column 13)",
+                                                      " (in 'ad-level-failing.stan', line 17, column 4 to column 17)",
+                                                      " (in 'ad-level-failing.stan', line 19, column 4 to column 59)",
+                                                      " (in 'ad-level-failing.stan', line 21, column 4 to column 30)",
+                                                      " (in 'ad-level-failing.stan', line 22, column 4 to column 48)",
+                                                      " (in 'ad-level-failing.stan', line 24, column 4 to column 16)",
+                                                      " (in 'ad-level-failing.stan', line 15, column 31 to line 25, column 3)"};
 
-struct nrfun_lp_functor__ {
-template <bool propto__, typename T0__, typename T_lp__,
-typename T_lp_accum__>
-void
-operator()(const T0__& x, const int& y, T_lp__& lp__,
-           T_lp_accum__& lp_accum__, std::ostream* pstream__)  const 
-{
-return nrfun_lp(x, y, lp__, lp_accum__, pstream__);
-}
-};
 
-int
-rfun(const int& y, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
+template <typename T0__, typename T1__, typename T2__, typename T3__>
+std::vector<stan::promote_args_t<T0__, T1__, T2__,
+T3__>>
+simple_SIR(const T0__& t, const std::vector<T1__>& y,
+           const std::vector<T2__>& theta, const std::vector<T3__>& x_r,
+           const std::vector<int>& x_i, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<T0__, T1__, T2__, T3__>;
   const static bool propto__ = true;
   (void) propto__;
   local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
   (void) DUMMY_VAR__;  // suppress unused var warning
   
   try {
-    int sym37__;
-    int sym36__;
-    int sym35__;
-    {
-      current_statement__ = 11;
-      if (logical_gt(y, 2)) {
-        {
-          current_statement__ = 10;
-          return (y + 24);
-        }
-      } else ;
-      current_statement__ = 88;
-      return (y + 2);
-    }
-  } catch (const std::exception& e) {
-    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
-      // Next line prevents compiler griping about no return
-      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
-  }
-  
-}
-
-struct rfun_functor__ {
-int
-operator()(const int& y, std::ostream* pstream__)  const 
-{
-return rfun(y, pstream__);
-}
-};
-
-template <bool propto__, typename T_lp__, typename T_lp_accum__>
-int
-rfun_lp(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) {
-  using local_scalar_t__ = double;
-  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
-  (void) DUMMY_VAR__;  // suppress unused var warning
-  
-  try {
+    local_scalar_t__ lcm_sym4__;
+    double lcm_sym3__;
+    double lcm_sym2__;
+    double lcm_sym1__;
     {
-      current_statement__ = 55;
-      lp_accum__.add(2);
-      current_statement__ = 89;
-      return 24;
+      current_statement__ = 25;
+      validate_non_negative_index("dydt", "4", 4);
+      std::vector<local_scalar_t__> dydt;
+      dydt = std::vector<local_scalar_t__>(4, DUMMY_VAR__);
+      
+      current_statement__ = 26;
+      assign(dydt, cons_list(index_uni(1), nil_index_list()),
+        (((-rvalue(theta, cons_list(index_uni(1), nil_index_list()), "theta")
+            * rvalue(y, cons_list(index_uni(4), nil_index_list()), "y")) /
+           (rvalue(y, cons_list(index_uni(4), nil_index_list()), "y") +
+             rvalue(theta, cons_list(index_uni(2), nil_index_list()),
+               "theta"))) *
+          rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")),
+        "assigning variable dydt");
+      lcm_sym4__ = (rvalue(theta, cons_list(index_uni(3), nil_index_list()),
+                      "theta") *
+                     rvalue(y, cons_list(index_uni(2), nil_index_list()),
+                       "y"));
+      assign(dydt, cons_list(index_uni(2), nil_index_list()),
+        ((((rvalue(theta, cons_list(index_uni(1), nil_index_list()), "theta")
+             * rvalue(y, cons_list(index_uni(4), nil_index_list()), "y")) /
+            (rvalue(y, cons_list(index_uni(4), nil_index_list()), "y") +
+              rvalue(theta, cons_list(index_uni(2), nil_index_list()),
+                "theta"))) *
+           rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")) -
+          lcm_sym4__), "assigning variable dydt");
+      current_statement__ = 27;
+      assign(dydt, cons_list(index_uni(3), nil_index_list()), lcm_sym4__,
+        "assigning variable dydt");
+      current_statement__ = 28;
+      assign(dydt, cons_list(index_uni(4), nil_index_list()),
+        ((rvalue(theta, cons_list(index_uni(4), nil_index_list()), "theta") *
+           rvalue(y, cons_list(index_uni(2), nil_index_list()), "y")) -
+          (rvalue(theta, cons_list(index_uni(5), nil_index_list()), "theta")
+            * rvalue(y, cons_list(index_uni(4), nil_index_list()), "y"))),
+        "assigning variable dydt");
+      current_statement__ = 29;
+      return dydt;
     }
   } catch (const std::exception& e) {
     stan::lang::rethrow_located(e, locations_array__[current_statement__]);
@@ -285,33 +188,45 @@ rfun_lp(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) {
   
 }
 
-struct rfun_lp_functor__ {
-template <bool propto__, typename T_lp__, typename T_lp_accum__>
-int
-operator()(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__)  const 
+struct simple_SIR_functor__ {
+template <typename T0__, typename T1__, typename T2__, typename T3__>
+std::vector<stan::promote_args_t<T0__, T1__, T2__,
+T3__>>
+operator()(const T0__& t, const std::vector<T1__>& y,
+           const std::vector<T2__>& theta, const std::vector<T3__>& x_r,
+           const std::vector<int>& x_i, std::ostream* pstream__)  const 
 {
-return rfun_lp(lp__, lp_accum__, pstream__);
+return simple_SIR(t, y, theta, x_r, x_i, pstream__);
 }
 };
 
-class optimizations_model : public model_base_crtp<optimizations_model> {
+class ad_level_failing_model : public model_base_crtp<ad_level_failing_model> {
 
  private:
   int pos__;
+  int N_t;
+  std::vector<double> t;
+  std::vector<double> y0;
+  std::vector<int> stoi_hat;
+  std::vector<double> B_hat;
+  double t0;
+  double kappa;
+  std::vector<double> x_r;
+  std::vector<int> x_i;
  
  public:
-  ~optimizations_model() { }
+  ~ad_level_failing_model() { }
   
-  std::string model_name() const { return "optimizations_model"; }
+  std::string model_name() const { return "ad_level_failing_model"; }
   
-  optimizations_model(stan::io::var_context& context__,
-                      unsigned int random_seed__ = 0,
-                      std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+  ad_level_failing_model(stan::io::var_context& context__,
+                         unsigned int random_seed__ = 0,
+                         std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
     typedef double local_scalar_t__;
     boost::ecuyer1988 base_rng__ = 
         stan::services::util::create_rng(random_seed__, 0);
     (void) base_rng__;  // suppress unused var warning
-    static const char* function__ = "optimizations_model_namespace::optimizations_model";
+    static const char* function__ = "ad_level_failing_model_namespace::ad_level_failing_model";
     (void) function__;  // suppress unused var warning
     local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
     (void) DUMMY_VAR__;  // suppress unused var warning
@@ -319,6 +234,71 @@ class optimizations_model : public model_base_crtp<optimizations_model> {
     try {
       pos__ = std::numeric_limits<int>::min();
       
+      pos__ = 1;
+      context__.validate_dims("data initialization","N_t","int",
+          context__.to_vec());
+      N_t = std::numeric_limits<int>::min();
+      
+      current_statement__ = 16;
+      N_t = context__.vals_i("N_t")[(1 - 1)];
+      current_statement__ = 17;
+      validate_non_negative_index("t", "N_t", N_t);
+      context__.validate_dims("data initialization","t","double",
+          context__.to_vec(N_t));
+      t = std::vector<double>(N_t, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 17;
+      assign(t, nil_index_list(), context__.vals_r("t"),
+        "assigning variable t");
+      current_statement__ = 18;
+      validate_non_negative_index("y0", "4", 4);
+      context__.validate_dims("data initialization","y0","double",
+          context__.to_vec(4));
+      y0 = std::vector<double>(4, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 18;
+      assign(y0, nil_index_list(), context__.vals_r("y0"),
+        "assigning variable y0");
+      current_statement__ = 19;
+      validate_non_negative_index("stoi_hat", "N_t", N_t);
+      context__.validate_dims("data initialization","stoi_hat","int",
+          context__.to_vec(N_t));
+      stoi_hat = std::vector<int>(N_t, std::numeric_limits<int>::min());
+      
+      current_statement__ = 19;
+      assign(stoi_hat, nil_index_list(), context__.vals_i("stoi_hat"),
+        "assigning variable stoi_hat");
+      current_statement__ = 20;
+      validate_non_negative_index("B_hat", "N_t", N_t);
+      context__.validate_dims("data initialization","B_hat","double",
+          context__.to_vec(N_t));
+      B_hat = std::vector<double>(N_t, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 20;
+      assign(B_hat, nil_index_list(), context__.vals_r("B_hat"),
+        "assigning variable B_hat");
+      t0 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 21;
+      t0 = 0;
+      kappa = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 22;
+      kappa = 1000000;
+      current_statement__ = 23;
+      validate_non_negative_index("x_r", "0", 0);
+      x_r = std::vector<double>(0, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 24;
+      validate_non_negative_index("x_i", "0", 0);
+      x_i = std::vector<int>(0, std::numeric_limits<int>::min());
+      
+      current_statement__ = 16;
+      current_statement__ = 16;
+      check_greater_or_equal(function__, "N_t", N_t, 0);
+      current_statement__ = 22;
+      current_statement__ = 22;
+      check_greater_or_equal(function__, "kappa", 1000000, 0);
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
       // Next line prevents compiler griping about no return
@@ -329,19 +309,8 @@ class optimizations_model : public model_base_crtp<optimizations_model> {
     try {
       num_params_r__ += 1;
       num_params_r__ += 1;
-      current_statement__ = 3;
-      validate_non_negative_index("x_matrix", "3", 3);
-      current_statement__ = 3;
-      validate_non_negative_index("x_matrix", "2", 2);
-      num_params_r__ += 3 * 2;
-      current_statement__ = 4;
-      validate_non_negative_index("x_vector", "2", 2);
-      num_params_r__ += 2;
-      current_statement__ = 5;
-      validate_non_negative_index("x_cov", "2", 2);
-      current_statement__ = 5;
-      validate_non_negative_index("x_cov", "2", 2);
-      num_params_r__ += 3;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
       // Next line prevents compiler griping about no return
@@ -355,7 +324,7 @@ class optimizations_model : public model_base_crtp<optimizations_model> {
     typedef T__ local_scalar_t__;
     T__ lp__(0.0);
     stan::math::accumulator<T__> lp_accum__;
-    static const char* function__ = "optimizations_model_namespace::log_prob";
+    static const char* function__ = "ad_level_failing_model_namespace::log_prob";
 (void) function__;  // suppress unused var warning
 
     stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
@@ -364,718 +333,234 @@ class optimizations_model : public model_base_crtp<optimizations_model> {
 
     
     try {
-      local_scalar_t__ sym110__;
-      int sym109__;
-      int sym108__;
-      int sym107__;
-      int sym106__;
-      int sym105__;
-      int sym104__;
-      int sym103__;
-      int sym102__;
-      int sym101__;
-      int sym100__;
-      int sym99__;
-      int sym98__;
-      int sym97__;
-      int sym96__;
-      int sym95__;
-      int sym94__;
-      int sym93__;
-      int sym92__;
-      int sym91__;
-      int sym90__;
-      int sym89__;
-      int sym88__;
-      int sym87__;
-      int sym86__;
-      int sym85__;
-      int sym84__;
-      int sym83__;
-      int sym82__;
-      int sym81__;
-      int sym80__;
-      int sym79__;
-      int sym78__;
-      int sym77__;
-      local_scalar_t__ theta;
-      theta = DUMMY_VAR__;
+      local_scalar_t__ lcm_sym29__;
+      double lcm_sym28__;
+      double lcm_sym27__;
+      double lcm_sym26__;
+      std::vector<local_scalar_t__> lcm_sym25__;
+      double lcm_sym24__;
+      double lcm_sym23__;
+      double lcm_sym22__;
+      double lcm_sym21__;
+      std::vector<std::vector<local_scalar_t__>> lcm_sym20__;
+      double lcm_sym19__;
+      double lcm_sym18__;
+      double lcm_sym17__;
+      double lcm_sym16__;
+      int lcm_sym15__;
+      int lcm_sym14__;
+      local_scalar_t__ beta;
+      beta = DUMMY_VAR__;
       
       current_statement__ = 1;
-      theta = in__.scalar();
-      local_scalar_t__ phi;
-      phi = DUMMY_VAR__;
+      beta = in__.scalar();
+      current_statement__ = 1;
+      if (jacobian__) {
+        current_statement__ = 1;
+        beta = stan::math::lb_constrain(beta, 0, lp__);
+      } else {
+        current_statement__ = 1;
+        beta = stan::math::lb_constrain(beta, 0);
+      }
+      local_scalar_t__ gamma;
+      gamma = DUMMY_VAR__;
       
       current_statement__ = 2;
-      phi = in__.scalar();
+      gamma = in__.scalar();
+      current_statement__ = 2;
+      if (jacobian__) {
+        current_statement__ = 2;
+        gamma = stan::math::lb_constrain(gamma, 0, lp__);
+      } else {
+        current_statement__ = 2;
+        gamma = stan::math::lb_constrain(gamma, 0);
+      }
+      local_scalar_t__ xi;
+      xi = DUMMY_VAR__;
+      
       current_statement__ = 3;
-      validate_non_negative_index("x_matrix", "3", 3);
+      xi = in__.scalar();
       current_statement__ = 3;
-      validate_non_negative_index("x_matrix", "2", 2);
-      Eigen::Matrix<local_scalar_t__, -1, -1> x_matrix;
-      x_matrix = Eigen::Matrix<local_scalar_t__, -1, -1>(3, 2);
-      stan::math::fill(x_matrix, DUMMY_VAR__);
+      if (jacobian__) {
+        current_statement__ = 3;
+        xi = stan::math::lb_constrain(xi, 0, lp__);
+      } else {
+        current_statement__ = 3;
+        xi = stan::math::lb_constrain(xi, 0);
+      }
+      local_scalar_t__ delta;
+      delta = DUMMY_VAR__;
       
-      current_statement__ = 3;
-      x_matrix = in__.matrix(3, 2);
       current_statement__ = 4;
-      validate_non_negative_index("x_vector", "2", 2);
-      Eigen::Matrix<local_scalar_t__, -1, 1> x_vector;
-      x_vector = Eigen::Matrix<local_scalar_t__, -1, 1>(2);
-      stan::math::fill(x_vector, DUMMY_VAR__);
-      
+      delta = in__.scalar();
       current_statement__ = 4;
-      x_vector = in__.vector(2);
+      if (jacobian__) {
+        current_statement__ = 4;
+        delta = stan::math::lb_constrain(delta, 0, lp__);
+      } else {
+        current_statement__ = 4;
+        delta = stan::math::lb_constrain(delta, 0);
+      }
       current_statement__ = 5;
-      validate_non_negative_index("x_cov", "2", 2);
+      validate_non_negative_index("y", "N_t", N_t);
       current_statement__ = 5;
-      validate_non_negative_index("x_cov", "2", 2);
-      Eigen::Matrix<local_scalar_t__, -1, -1> x_cov;
-      x_cov = Eigen::Matrix<local_scalar_t__, -1, -1>(2, 2);
-      stan::math::fill(x_cov, DUMMY_VAR__);
-      
-      Eigen::Matrix<local_scalar_t__, -1, 1> x_cov_in__;
-      x_cov_in__ = Eigen::Matrix<local_scalar_t__, -1, 1>(3);
-      stan::math::fill(x_cov_in__, DUMMY_VAR__);
+      validate_non_negative_index("y", "4", 4);
+      std::vector<std::vector<local_scalar_t__>> y;
+      y = std::vector<std::vector<local_scalar_t__>>(N_t, std::vector<local_scalar_t__>(4, DUMMY_VAR__));
       
-      current_statement__ = 5;
-      x_cov_in__ = in__.vector(3);
       {
-        double x;
-        x = std::numeric_limits<double>::quiet_NaN();
+        current_statement__ = 6;
+        validate_non_negative_index("theta", "5", 5);
+        std::vector<double> theta;
+        theta = std::vector<double>(5, std::numeric_limits<double>::quiet_NaN());
         
-        current_statement__ = 9;
-        for (int sym1__ = 1; sym1__ <= 1; ++sym1__) {
-          {
-            current_statement__ = 7;
-            lp_accum__.add(3);
-          }}
-        int sym4__;
-        for (int sym3__ = 1; sym3__ <= 1; ++sym3__) {
+        assign(lcm_sym25__, nil_index_list(),
+          stan::math::array_builder<local_scalar_t__>().add(beta)
+          .add(1000000).add(gamma).add(xi).add(delta).array(),
+          "assigning variable lcm_sym25__");
+        assign(lcm_sym20__, nil_index_list(),
+          integrate_ode_rk45(simple_SIR_functor__(), y0, 0, t, lcm_sym25__,
+            x_r, x_i, pstream__), "assigning variable lcm_sym20__");
+        assign(y, nil_index_list(), lcm_sym20__, "assigning variable y");
+      }
+      current_statement__ = 5;
+      if (logical_gte(N_t, 1)) {
+        {
           {
             {
+              lcm_sym29__ = rvalue(lcm_sym20__,
+                              cons_list(index_uni(1),
+                                cons_list(index_uni(1), nil_index_list())),
+                              "lcm_sym20__");
+              check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                     lcm_sym29__, 0);
               {
-                sym4__ = 27;
-                break;
+                current_statement__ = 5;
+                current_statement__ = 5;
+                check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                       rvalue(lcm_sym20__,
+                                         cons_list(index_uni(1),
+                                           cons_list(index_uni(2),
+                                             nil_index_list())),
+                                         "lcm_sym20__"), 0);
               }
-            }
-            sym4__ = 5;
-            break;
-          }}
-        if (pstream__) {
-          stan_print(pstream__, sym4__);
-          stan_print(pstream__, "\n");
-        }
-        int sym7__;
-        for (int sym6__ = 1; sym6__ <= 1; ++sym6__) {
-          {
-            {
               {
-                sym7__ = 28;
-                break;
+                current_statement__ = 5;
+                current_statement__ = 5;
+                check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                       rvalue(lcm_sym20__,
+                                         cons_list(index_uni(1),
+                                           cons_list(index_uni(3),
+                                             nil_index_list())),
+                                         "lcm_sym20__"), 0);
               }
-            }
-            sym7__ = 6;
-            break;
-          }}
-        if (sym7__) {
-          {
-            current_statement__ = 13;
-            if (pstream__) {
-              stan_print(pstream__, "a");
-              stan_print(pstream__, "\n");
-            }
-          }
-        } else ;
-        int sym10__;
-        int sym13__;
-        for (int sym9__ = 1; sym9__ <= 1; ++sym9__) {
-          {
-            {
-              {
-                sym10__ = 31;
-                break;
-              }
-            }
-            sym10__ = 9;
-            break;
-          }}
-        for (int sym12__ = 1; sym12__ <= 1; ++sym12__) {
-          {
-            {
-              {
-                sym13__ = 29;
-                break;
-              }
-            }
-            sym13__ = 7;
-            break;
-          }}
-        if (logical_lte(sym10__, sym13__)) {
-          {
-            {
-              {
-                int sym16__;
-                for (int sym15__ = 1; sym15__ <= 1; ++sym15__) {
-                  {
-                    {
-                      {
-                        sym16__ = 32;
-                        break;
-                      }
-                    }
-                    sym16__ = 10;
-                    break;
-                  }}
-                lp_accum__.add(sym16__);
-                current_statement__ = 14;
-                for (int sym17__ = 1; sym17__ <= 1; ++sym17__) {
-                  {
-                    current_statement__ = 7;
-                    lp_accum__.add(3);
-                  }}
-              }
-              sym107__ = (sym10__ + 1);
-              for (int sym12__ = 1; sym12__ <= 1; ++sym12__) {
-                {
-                  {
-                    {
-                      sym13__ = 29;
-                      sym107__ = (sym10__ + 1);
-                      break;
-                    }
-                  }
-                  sym13__ = 7;
-                  sym107__ = (sym10__ + 1);
-                  break;
-                }}
-            }
-            for (int i = sym107__; i <= sym13__; ++i) {
-              {
-                {
-                  int sym16__;
-                  for (int sym15__ = 1; sym15__ <= 1; ++sym15__) {
-                    {
-                      {
-                        {
-                          sym16__ = 32;
-                          break;
-                        }
-                      }
-                      sym16__ = 10;
-                      break;
-                    }}
-                  lp_accum__.add(sym16__);
-                  current_statement__ = 14;
-                  for (int sym17__ = 1; sym17__ <= 1; ++sym17__) {
-                    {
-                      current_statement__ = 7;
-                      lp_accum__.add(3);
-                    }}
-                }
-                for (int sym12__ = 1; sym12__ <= 1; ++sym12__) {
-                  {
-                    {
-                      {
-                        sym13__ = 29;
-                        break;
-                      }
-                    }
-                    sym13__ = 7;
-                    break;
-                  }}
-              }}
-          }
-        } else ;
-        {
-          {
-            {
-              current_statement__ = 16;
-              lp_accum__.add(53);
-            }
-            {
-              {
-                current_statement__ = 16;
-                lp_accum__.add(53);
-              }
-            }
-            {
-              {
-                current_statement__ = 16;
-                lp_accum__.add(53);
-              }
-            }
-            {
-              {
-                current_statement__ = 16;
-                lp_accum__.add(53);
-              }
-            }
-            {
               {
-                current_statement__ = 16;
-                lp_accum__.add(53);
+                current_statement__ = 5;
+                current_statement__ = 5;
+                check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                       rvalue(lcm_sym20__,
+                                         cons_list(index_uni(1),
+                                           cons_list(index_uni(4),
+                                             nil_index_list())),
+                                         "lcm_sym20__"), 0);
               }
             }
           }
-        }
-        {
-          {
-            {
-              {
-                {
-                  {
-                    {
-                      {
-                        {
-                          current_statement__ = 19;
-                          lp_accum__.add(53);
-                        }
-                        {
-                          {
-                            current_statement__ = 19;
-                            lp_accum__.add(53);
-                          }
-                        }
-                      }
-                    }
-                  }
-                  {
-                    {
-                      sym109__ = (2 * 2);
-                      if (logical_lte(2, sym109__)) {
-                        {
-                          {
-                            sym106__ = (2 + 1);
-                            lp_accum__.add(53);
-                          }
-                          current_statement__ = 19;
-                          for (int k = sym106__; k <= sym109__; ++k) {
-                            {
-                              current_statement__ = 19;
-                              lp_accum__.add(53);
-                            }}
-                        }
-                      } else ;
-                    }
-                  }
-                  {
-                    {
-                      sym109__ = (3 * 2);
-                      if (logical_lte(3, sym109__)) {
-                        {
-                          {
-                            sym106__ = (3 + 1);
-                            lp_accum__.add(53);
-                          }
-                          current_statement__ = 19;
-                          for (int k = sym106__; k <= sym109__; ++k) {
-                            {
-                              current_statement__ = 19;
-                              lp_accum__.add(53);
-                            }}
-                        }
-                      } else ;
-                    }
-                  }
-                }
-              }
-            }
-            {
-              {
-                sym105__ = (2 + 2);
-                if (logical_lte(2, sym105__)) {
-                  {
-                    {
-                      sym108__ = (2 * 2);
-                      if (logical_lte(2, sym108__)) {
-                        {
-                          {
-                            sym104__ = (2 + 1);
-                            lp_accum__.add(53);
-                          }
-                          current_statement__ = 19;
-                          for (int k = sym104__; k <= sym108__; ++k) {
-                            {
-                              current_statement__ = 19;
-                              lp_accum__.add(53);
-                            }}
-                        }
-                      } else {
-                        sym104__ = (2 + 1);
-                      }
-                    }
-                    current_statement__ = 20;
-                    for (int j = sym104__; j <= sym105__; ++j) {
-                      {
-                        sym109__ = (j * 2);
-                        if (logical_lte(j, sym109__)) {
-                          {
-                            {
-                              sym106__ = (j + 1);
-                              lp_accum__.add(53);
-                            }
-                            current_statement__ = 19;
-                            for (int k = sym106__; k <= sym109__; ++k) {
-                              {
-                                current_statement__ = 19;
-                                lp_accum__.add(53);
-                              }}
-                          }
-                        } else ;
-                      }}
-                  }
-                } else ;
-              }
-            }
-            {
-              {
-                sym105__ = (3 + 2);
-                if (logical_lte(3, sym105__)) {
-                  {
-                    {
-                      sym108__ = (3 * 2);
-                      if (logical_lte(3, sym108__)) {
-                        {
-                          {
-                            sym104__ = (3 + 1);
-                            lp_accum__.add(53);
-                          }
-                          current_statement__ = 19;
-                          for (int k = sym104__; k <= sym108__; ++k) {
-                            {
-                              current_statement__ = 19;
-                              lp_accum__.add(53);
-                            }}
-                        }
-                      } else {
-                        sym104__ = (3 + 1);
-                      }
-                    }
-                    current_statement__ = 20;
-                    for (int j = sym104__; j <= sym105__; ++j) {
-                      {
-                        sym109__ = (j * 2);
-                        if (logical_lte(j, sym109__)) {
-                          {
-                            {
-                              sym106__ = (j + 1);
-                              lp_accum__.add(53);
-                            }
-                            current_statement__ = 19;
-                            for (int k = sym106__; k <= sym109__; ++k) {
-                              {
-                                current_statement__ = 19;
-                                lp_accum__.add(53);
-                              }}
-                          }
-                        } else ;
-                      }}
-                  }
-                } else ;
-              }
-            }
-            {
-              {
-                sym105__ = (4 + 2);
-                if (logical_lte(4, sym105__)) {
-                  {
-                    {
-                      sym108__ = (4 * 2);
-                      if (logical_lte(4, sym108__)) {
-                        {
-                          {
-                            sym104__ = (4 + 1);
-                            lp_accum__.add(53);
-                          }
-                          current_statement__ = 19;
-                          for (int k = sym104__; k <= sym108__; ++k) {
-                            {
-                              current_statement__ = 19;
-                              lp_accum__.add(53);
-                            }}
-                        }
-                      } else {
-                        sym104__ = (4 + 1);
-                      }
-                    }
-                    current_statement__ = 20;
-                    for (int j = sym104__; j <= sym105__; ++j) {
-                      {
-                        sym109__ = (j * 2);
-                        if (logical_lte(j, sym109__)) {
-                          {
-                            {
-                              sym106__ = (j + 1);
-                              lp_accum__.add(53);
-                            }
-                            current_statement__ = 19;
-                            for (int k = sym106__; k <= sym109__; ++k) {
-                              {
-                                current_statement__ = 19;
-                                lp_accum__.add(53);
-                              }}
-                          }
-                        } else ;
-                      }}
-                  }
-                } else ;
-              }
-            }
+          for (int sym1__ = 2; sym1__ <= N_t; ++sym1__) {
             {
+              current_statement__ = 5;
+              current_statement__ = 5;
+              check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                     rvalue(lcm_sym20__,
+                                       cons_list(index_uni(sym1__),
+                                         cons_list(index_uni(1),
+                                           nil_index_list())), "lcm_sym20__"),
+                                     0);
               {
-                sym105__ = (5 + 2);
-                if (logical_lte(5, sym105__)) {
-                  {
-                    {
-                      sym108__ = (5 * 2);
-                      if (logical_lte(5, sym108__)) {
-                        {
-                          {
-                            sym104__ = (5 + 1);
-                            lp_accum__.add(53);
-                          }
-                          current_statement__ = 19;
-                          for (int k = sym104__; k <= sym108__; ++k) {
-                            {
-                              current_statement__ = 19;
-                              lp_accum__.add(53);
-                            }}
-                        }
-                      } else {
-                        sym104__ = (5 + 1);
-                      }
-                    }
-                    current_statement__ = 20;
-                    for (int j = sym104__; j <= sym105__; ++j) {
-                      {
-                        sym109__ = (j * 2);
-                        if (logical_lte(j, sym109__)) {
-                          {
-                            {
-                              sym106__ = (j + 1);
-                              lp_accum__.add(53);
-                            }
-                            current_statement__ = 19;
-                            for (int k = sym106__; k <= sym109__; ++k) {
-                              {
-                                current_statement__ = 19;
-                                lp_accum__.add(53);
-                              }}
-                          }
-                        } else ;
-                      }}
-                  }
-                } else ;
-              }
-            }
-          }
-        }
-        current_statement__ = 27;
-        for (int i = 1; i <= 5; ++i) {
-          {
-            current_statement__ = 24;
-            if (logical_gt(i, 4)) {
-              {
-                break;
-              }
-            } else ;
-            current_statement__ = 25;
-            lp_accum__.add(2);
-          }}
-        current_statement__ = 32;
-        for (int i = 1; i <= 5; ++i) {
-          {
-            current_statement__ = 29;
-            if (logical_gt(i, 4)) {
-              {
-                continue;
+                current_statement__ = 5;
+                current_statement__ = 5;
+                check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                       rvalue(lcm_sym20__,
+                                         cons_list(index_uni(sym1__),
+                                           cons_list(index_uni(2),
+                                             nil_index_list())),
+                                         "lcm_sym20__"), 0);
               }
-            } else ;
-            current_statement__ = 30;
-            lp_accum__.add(2);
-          }}
-        current_statement__ = 37;
-        for (int i = 1; i <= 5; ++i) {
-          {
-            current_statement__ = 34;
-            if (logical_gt(i, 4)) {
               {
-                continue;
+                current_statement__ = 5;
+                current_statement__ = 5;
+                check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                       rvalue(lcm_sym20__,
+                                         cons_list(index_uni(sym1__),
+                                           cons_list(index_uni(3),
+                                             nil_index_list())),
+                                         "lcm_sym20__"), 0);
               }
-            } else ;
-            current_statement__ = 35;
-            lp_accum__.add(2);
-          }}
-        current_statement__ = 38;
-        lp_accum__.add(3);
-        current_statement__ = 39;
-        lp_accum__.add(2);
-        current_statement__ = 40;
-        lp_accum__.add(247);
-        current_statement__ = 41;
-        lp_accum__.add(576);
-        current_statement__ = 42;
-        lp_accum__.add(5880);
-        double z;
-        z = std::numeric_limits<double>::quiet_NaN();
-        
-        current_statement__ = 44;
-        lp_accum__.add(5880);
-        current_statement__ = 45;
-        lp_accum__.add(5880);
-        current_statement__ = 46;
-        lp_accum__.add(2);
-        {
-          double y;
-          y = std::numeric_limits<double>::quiet_NaN();
-          
-          current_statement__ = 48;
-          lp_accum__.add(24);
-        }
-        {
-          double y;
-          y = std::numeric_limits<double>::quiet_NaN();
-          
-          current_statement__ = 51;
-          lp_accum__.add(245);
-        }
-        {
-          current_statement__ = 53;
-          lp_accum__.add(2);
-        }
-        int sym20__;
-        for (int sym19__ = 1; sym19__ <= 1; ++sym19__) {
-          {
-            current_statement__ = 55;
-            lp_accum__.add(2);
-            break;
-          }}
-        current_statement__ = 58;
-        while (576) {
-          {
-            break;
-          }
-        }
-        int sym23__;
-        for (int sym22__ = 1; sym22__ <= 1; ++sym22__) {
-          {
-            current_statement__ = 55;
-            lp_accum__.add(2);
-            sym23__ = 24;
-            break;
-          }}
-        while (sym23__) {
-          {
-            {
-              break;
-            }
-            for (int sym22__ = 1; sym22__ <= 1; ++sym22__) {
-              {
-                current_statement__ = 55;
-                lp_accum__.add(2);
-                sym23__ = 24;
-                break;
-              }}
-          }
-        }
-        current_statement__ = 61;
-        for (int i = 31; i <= 225; ++i) { {
-                                            continue;
-                                          }}
-        current_statement__ = 63;
-        for (int i = 31; i <= 225; ++i) { {
-                                            break;
-                                          }}
-        int sym26__;
-        for (int sym25__ = 1; sym25__ <= 1; ++sym25__) {
-          {
-            current_statement__ = 55;
-            lp_accum__.add(2);
-            sym26__ = 24;
-            break;
-          }}
-        for (int i = sym26__; i <= 225; ++i) { {
-                                                 continue;
-                                               }}
-        int sym29__;
-        for (int sym28__ = 1; sym28__ <= 1; ++sym28__) {
-          {
-            current_statement__ = 55;
-            lp_accum__.add(2);
-            sym29__ = 24;
-            break;
-          }}
-        for (int i = sym29__; i <= 225; ++i) { {
-                                                 break;
-                                               }}
-        int sym32__;
-        for (int sym31__ = 1; sym31__ <= 1; ++sym31__) {
-          {
-            current_statement__ = 55;
-            lp_accum__.add(2);
-            break;
-          }}
-        {
-          current_statement__ = 66;
-          lp_accum__.add(1);
-          current_statement__ = 67;
-          lp_accum__.add(24);
-        }
-        {
-          {
-            current_statement__ = 69;
-            lp_accum__.add(1);
-          }
-        }
-        double temp;
-        temp = std::numeric_limits<double>::quiet_NaN();
-        
-        {
-          {
-            current_statement__ = 73;
-            if (pstream__) {
-              stan_print(pstream__, "hello");
-              stan_print(pstream__, "\n");
-            }
-          }
-        }
-        double temp2;
-        temp2 = std::numeric_limits<double>::quiet_NaN();
-        
-        {
-          {
-            {
-              current_statement__ = 76;
-              lp_accum__.add(4);
-              current_statement__ = 77;
-              lp_accum__.add(6);
-            }
-            {
               {
-                current_statement__ = 76;
-                lp_accum__.add(4);
-                current_statement__ = 77;
-                lp_accum__.add(6);
+                current_statement__ = 5;
+                current_statement__ = 5;
+                check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                       rvalue(lcm_sym20__,
+                                         cons_list(index_uni(sym1__),
+                                           cons_list(index_uni(4),
+                                             nil_index_list())),
+                                         "lcm_sym20__"), 0);
               }
-            }
-          }
-        }
-        double dataonlyvar;
-        dataonlyvar = std::numeric_limits<double>::quiet_NaN();
-        
-        current_statement__ = 81;
-        lp_accum__.add(159);
-        double paramvar;
-        paramvar = std::numeric_limits<double>::quiet_NaN();
-        
-        {
-          {
-            sym110__ = (theta * 34);
-          }
+            }}
         }
-        current_statement__ = 85;
-        lp_accum__.add(sym110__);
+      } else {
+        lcm_sym29__ = rvalue(lcm_sym20__,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(1), nil_index_list())),
+                        "lcm_sym20__");
+      }
+      {
+        current_statement__ = 8;
+        lp_accum__.add(cauchy_log<propto__>(beta, 0, 2.5));
+        current_statement__ = 9;
+        lp_accum__.add(cauchy_log<propto__>(gamma, 0, 1));
+        current_statement__ = 10;
+        lp_accum__.add(cauchy_log<propto__>(xi, 0, 25));
+        current_statement__ = 11;
+        lp_accum__.add(cauchy_log<propto__>(delta, 0, 1));
+        current_statement__ = 12;
+        lp_accum__.add(
+          poisson_log<propto__>(
+            rvalue(stoi_hat, cons_list(index_uni(1), nil_index_list()),
+              "stoi_hat"),
+            (rvalue(y0, cons_list(index_uni(1), nil_index_list()), "y0") -
+              lcm_sym29__)));
+        current_statement__ = 14;
+        if (logical_gte(N_t, 2)) {
+          current_statement__ = 13;
+          lp_accum__.add(
+            poisson_log<propto__>(
+              rvalue(stoi_hat, cons_list(index_uni(2), nil_index_list()),
+                "stoi_hat"),
+              (lcm_sym29__ -
+                rvalue(lcm_sym20__,
+                  cons_list(index_uni(2),
+                    cons_list(index_uni(1), nil_index_list())),
+                  "lcm_sym20__"))));
+          for (int n = 3; n <= N_t; ++n) {
+            current_statement__ = 13;
+            lp_accum__.add(
+              poisson_log<propto__>(
+                rvalue(stoi_hat, cons_list(index_uni(n), nil_index_list()),
+                  "stoi_hat"),
+                (rvalue(lcm_sym20__,
+                   cons_list(index_uni((n - 1)),
+                     cons_list(index_uni(1), nil_index_list())),
+                   "lcm_sym20__") -
+                  rvalue(lcm_sym20__,
+                    cons_list(index_uni(n),
+                      cons_list(index_uni(1), nil_index_list())),
+                    "lcm_sym20__"))));}
+        } 
+        current_statement__ = 15;
+        lp_accum__.add(
+          lognormal_log<propto__>(B_hat,
+            stan::math::log(col(to_matrix(lcm_sym20__), 4)), 0.15));
       }
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
@@ -1096,7 +581,7 @@ class optimizations_model : public model_base_crtp<optimizations_model> {
     using local_scalar_t__ = double;
     vars__.resize(0);
     stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
-    static const char* function__ = "optimizations_model_namespace::write_array";
+    static const char* function__ = "ad_level_failing_model_namespace::write_array";
 (void) function__;  // suppress unused var warning
 
     (void) function__;  // suppress unused var warning
@@ -1109,216 +594,32552 @@ class optimizations_model : public model_base_crtp<optimizations_model> {
 
     
     try {
-      double sym76__;
-      double sym75__;
-      double sym74__;
-      double sym73__;
-      double sym72__;
-      double sym71__;
-      double sym70__;
-      double sym69__;
-      double sym68__;
-      double sym67__;
-      Eigen::Matrix<double, -1, -1> sym66__;
-      int sym65__;
-      int sym64__;
-      double sym63__;
-      int sym62__;
-      int sym61__;
-      double sym60__;
-      double theta;
-      theta = std::numeric_limits<double>::quiet_NaN();
+      double lcm_sym13__;
+      double lcm_sym12__;
+      double lcm_sym11__;
+      double lcm_sym10__;
+      std::vector<double> lcm_sym9__;
+      std::vector<std::vector<double>> lcm_sym8__;
+      int lcm_sym7__;
+      int lcm_sym6__;
+      int lcm_sym5__;
+      double beta;
+      beta = std::numeric_limits<double>::quiet_NaN();
       
       current_statement__ = 1;
-      theta = in__.scalar();
-      double phi;
-      phi = std::numeric_limits<double>::quiet_NaN();
+      beta = in__.scalar();
+      current_statement__ = 1;
+      beta = stan::math::lb_constrain(beta, 0);
+      double gamma;
+      gamma = std::numeric_limits<double>::quiet_NaN();
       
       current_statement__ = 2;
-      phi = in__.scalar();
+      gamma = in__.scalar();
+      current_statement__ = 2;
+      gamma = stan::math::lb_constrain(gamma, 0);
+      double xi;
+      xi = std::numeric_limits<double>::quiet_NaN();
+      
       current_statement__ = 3;
-      validate_non_negative_index("x_matrix", "3", 3);
+      xi = in__.scalar();
       current_statement__ = 3;
-      validate_non_negative_index("x_matrix", "2", 2);
-      Eigen::Matrix<double, -1, -1> x_matrix;
-      x_matrix = Eigen::Matrix<double, -1, -1>(3, 2);
-      stan::math::fill(x_matrix, std::numeric_limits<double>::quiet_NaN());
+      xi = stan::math::lb_constrain(xi, 0);
+      double delta;
+      delta = std::numeric_limits<double>::quiet_NaN();
       
-      current_statement__ = 3;
-      x_matrix = in__.matrix(3, 2);
       current_statement__ = 4;
-      validate_non_negative_index("x_vector", "2", 2);
-      Eigen::Matrix<double, -1, 1> x_vector;
-      x_vector = Eigen::Matrix<double, -1, 1>(2);
-      stan::math::fill(x_vector, std::numeric_limits<double>::quiet_NaN());
-      
+      delta = in__.scalar();
       current_statement__ = 4;
-      x_vector = in__.vector(2);
+      delta = stan::math::lb_constrain(delta, 0);
       current_statement__ = 5;
-      validate_non_negative_index("x_cov", "2", 2);
+      validate_non_negative_index("y", "N_t", N_t);
       current_statement__ = 5;
-      validate_non_negative_index("x_cov", "2", 2);
-      Eigen::Matrix<double, -1, -1> x_cov;
-      x_cov = Eigen::Matrix<double, -1, -1>(2, 2);
-      stan::math::fill(x_cov, std::numeric_limits<double>::quiet_NaN());
-      
-      Eigen::Matrix<double, -1, 1> x_cov_in__;
-      x_cov_in__ = Eigen::Matrix<double, -1, 1>(3);
-      stan::math::fill(x_cov_in__, std::numeric_limits<double>::quiet_NaN());
+      validate_non_negative_index("y", "4", 4);
+      std::vector<std::vector<double>> y;
+      y = std::vector<std::vector<double>>(N_t, std::vector<double>(4, std::numeric_limits<double>::quiet_NaN()));
       
-      current_statement__ = 5;
-      x_cov_in__ = in__.vector(3);
-      assign(sym66__, nil_index_list(),
-        stan::math::cov_matrix_constrain(x_cov_in__, 2),
-        "assigning variable sym66__");
-      assign(x_cov, nil_index_list(), sym66__, "assigning variable x_cov");
-      vars__.push_back(theta);
-      vars__.push_back(phi);
+      vars__.push_back(beta);
+      vars__.push_back(gamma);
+      vars__.push_back(xi);
+      vars__.push_back(delta);
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      {
+        current_statement__ = 6;
+        validate_non_negative_index("theta", "5", 5);
+        std::vector<double> theta;
+        theta = std::vector<double>(5, std::numeric_limits<double>::quiet_NaN());
+        
+        assign(lcm_sym9__, nil_index_list(),
+          stan::math::array_builder<double>().add(beta).add(1000000)
+          .add(gamma).add(xi).add(delta).array(),
+          "assigning variable lcm_sym9__");
+        assign(lcm_sym8__, nil_index_list(),
+          integrate_ode_rk45(simple_SIR_functor__(), y0, 0, t, lcm_sym9__,
+            x_r, x_i, pstream__), "assigning variable lcm_sym8__");
+        assign(y, nil_index_list(), lcm_sym8__, "assigning variable y");
+      }
       {
+        lcm_sym5__ = logical_gte(N_t, 1);
+        if (lcm_sym5__) {
+          vars__.push_back(
+            rvalue(lcm_sym8__,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "lcm_sym8__"));
+          for (int sym2__ = 2; sym2__ <= N_t; ++sym2__) {
+            vars__.push_back(
+              rvalue(lcm_sym8__,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "lcm_sym8__"));
+          }
+        } 
         {
-          {
-            {
-              {
-                {
-                  vars__.push_back(
-                    rvalue(x_matrix,
-                      cons_list(index_uni(1),
-                        cons_list(index_uni(1), nil_index_list())),
-                      "x_matrix"));
-                }
-                {
-                  {
-                    vars__.push_back(
-                      rvalue(x_matrix,
-                        cons_list(index_uni(2),
-                          cons_list(index_uni(1), nil_index_list())),
-                        "x_matrix"));
-                  }
-                }
-                {
-                  {
-                    vars__.push_back(
-                      rvalue(x_matrix,
-                        cons_list(index_uni(3),
-                          cons_list(index_uni(1), nil_index_list())),
-                        "x_matrix"));
-                  }
-                }
-              }
+          if (lcm_sym5__) {
+            vars__.push_back(
+              rvalue(lcm_sym8__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(2), nil_index_list())), "lcm_sym8__"));
+            for (int sym2__ = 2; sym2__ <= N_t; ++sym2__) {
+              vars__.push_back(
+                rvalue(lcm_sym8__,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(2), nil_index_list())), "lcm_sym8__"));
             }
-          }
-          {
-            {
-              {
-                {
-                  {
-                    vars__.push_back(
-                      rvalue(x_matrix,
-                        cons_list(index_uni(1),
-                          cons_list(index_uni(2), nil_index_list())),
-                        "x_matrix"));
-                  }
-                  {
-                    {
-                      vars__.push_back(
-                        rvalue(x_matrix,
-                          cons_list(index_uni(2),
-                            cons_list(index_uni(2), nil_index_list())),
-                          "x_matrix"));
-                    }
-                  }
-                  {
-                    {
-                      vars__.push_back(
-                        rvalue(x_matrix,
-                          cons_list(index_uni(3),
-                            cons_list(index_uni(2), nil_index_list())),
-                          "x_matrix"));
-                    }
-                  }
-                }
-              }
+          } 
+        }
+        {
+          if (lcm_sym5__) {
+            vars__.push_back(
+              rvalue(lcm_sym8__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(3), nil_index_list())), "lcm_sym8__"));
+            for (int sym2__ = 2; sym2__ <= N_t; ++sym2__) {
+              vars__.push_back(
+                rvalue(lcm_sym8__,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(3), nil_index_list())), "lcm_sym8__"));
             }
-          }
+          } 
         }
-      }
-      {
         {
-          {
+          if (lcm_sym5__) {
             vars__.push_back(
-              rvalue(x_vector, cons_list(index_uni(1), nil_index_list()),
-                "x_vector"));
-          }
-          {
-            {
+              rvalue(lcm_sym8__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(4), nil_index_list())), "lcm_sym8__"));
+            for (int sym2__ = 2; sym2__ <= N_t; ++sym2__) {
               vars__.push_back(
-                rvalue(x_vector, cons_list(index_uni(2), nil_index_list()),
-                  "x_vector"));
+                rvalue(lcm_sym8__,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(4), nil_index_list())), "lcm_sym8__"));
             }
-          }
+          } 
         }
       }
-      {
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double beta;
+      beta = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      beta = context__.vals_r("beta")[(1 - 1)];
+      current_statement__ = 1;
+      beta = stan::math::lb_free(beta, 0);
+      double gamma;
+      gamma = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      gamma = context__.vals_r("gamma")[(1 - 1)];
+      current_statement__ = 2;
+      gamma = stan::math::lb_free(gamma, 0);
+      double xi;
+      xi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      xi = context__.vals_r("xi")[(1 - 1)];
+      current_statement__ = 3;
+      xi = stan::math::lb_free(xi, 0);
+      double delta;
+      delta = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      delta = context__.vals_r("delta")[(1 - 1)];
+      current_statement__ = 4;
+      delta = stan::math::lb_free(delta, 0);
+      vars__.push_back(beta);
+      vars__.push_back(gamma);
+      vars__.push_back(xi);
+      vars__.push_back(delta);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("beta");
+    names__.push_back("gamma");
+    names__.push_back("xi");
+    names__.push_back("delta");
+    names__.push_back("y");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(N_t);
+    
+    dims__.push_back(4);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "beta");
+    param_names__.push_back(std::string() + "gamma");
+    param_names__.push_back(std::string() + "xi");
+    param_names__.push_back(std::string() + "delta");
+    if (emit_transformed_parameters__) {
+      for (int sym30__ = 1; sym30__ <= 4; ++sym30__) {
         {
-          {
+          for (int sym31__ = 1; sym31__ <= N_t; ++sym31__) {
             {
-              {
-                {
-                  vars__.push_back(
-                    rvalue(sym66__,
-                      cons_list(index_uni(1),
-                        cons_list(index_uni(1), nil_index_list())),
-                      "sym66__"));
-                }
-                {
-                  {
-                    vars__.push_back(
-                      rvalue(sym66__,
-                        cons_list(index_uni(2),
-                          cons_list(index_uni(1), nil_index_list())),
-                        "sym66__"));
-                  }
-                }
-              }
-            }
-          }
-          {
+              param_names__.push_back(std::string() + "y" + '.' + std::to_string(sym31__) + '.' + std::to_string(sym30__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "beta");
+    param_names__.push_back(std::string() + "gamma");
+    param_names__.push_back(std::string() + "xi");
+    param_names__.push_back(std::string() + "delta");
+    if (emit_transformed_parameters__) {
+      for (int sym30__ = 1; sym30__ <= 4; ++sym30__) {
+        {
+          for (int sym31__ = 1; sym31__ <= N_t; ++sym31__) {
             {
-              {
-                {
-                  {
-                    vars__.push_back(
-                      rvalue(sym66__,
-                        cons_list(index_uni(1),
-                          cons_list(index_uni(2), nil_index_list())),
-                        "sym66__"));
-                  }
-                  {
-                    {
-                      vars__.push_back(
-                        rvalue(sym66__,
-                          cons_list(index_uni(2),
-                            cons_list(index_uni(2), nil_index_list())),
-                          "sym66__"));
-                    }
-                  }
-                }
-              }
-            }
-          }
+              param_names__.push_back(std::string() + "y" + '.' + std::to_string(sym31__) + '.' + std::to_string(sym30__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"gamma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"xi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"delta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y\",\"type\":{\"name\":\"array\",\"length\":" << N_t << ",\"element_type\":{\"name\":\"array\",\"length\":" << 4 << ",\"element_type\":{\"name\":\"real\"}}},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"gamma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"xi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"delta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y\",\"type\":{\"name\":\"array\",\"length\":" << N_t << ",\"element_type\":{\"name\":\"array\",\"length\":" << 4 << ",\"element_type\":{\"name\":\"real\"}}},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef ad_level_failing_model_namespace::ad_level_failing_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp copy_fail.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace copy_fail_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'copy_fail.stan', line 71, column 2 to column 31)",
+                                                      " (in 'copy_fail.stan', line 72, column 2 to column 40)",
+                                                      " (in 'copy_fail.stan', line 76, column 2 to column 51)",
+                                                      " (in 'copy_fail.stan', line 77, column 2 to column 49)",
+                                                      " (in 'copy_fail.stan', line 78, column 2 to column 49)",
+                                                      " (in 'copy_fail.stan', line 83, column 6 to column 20)",
+                                                      " (in 'copy_fail.stan', line 84, column 6 to column 18)",
+                                                      " (in 'copy_fail.stan', line 82, column 32 to line 85, column 5)",
+                                                      " (in 'copy_fail.stan', line 87, column 6 to column 32)",
+                                                      " (in 'copy_fail.stan', line 88, column 6 to column 23)",
+                                                      " (in 'copy_fail.stan', line 86, column 38 to line 89, column 5)",
+                                                      " (in 'copy_fail.stan', line 86, column 4 to line 89, column 5)",
+                                                      " (in 'copy_fail.stan', line 81, column 20 to line 90, column 3)",
+                                                      " (in 'copy_fail.stan', line 26, column 4 to column 34)",
+                                                      " (in 'copy_fail.stan', line 29, column 6 to column 32)",
+                                                      " (in 'copy_fail.stan', line 32, column 8 to column 37)",
+                                                      " (in 'copy_fail.stan', line 33, column 8 to column 32)",
+                                                      " (in 'copy_fail.stan', line 41, column 8 to line 42, column 83)",
+                                                      " (in 'copy_fail.stan', line 30, column 37 to line 43, column 7)",
+                                                      " (in 'copy_fail.stan', line 28, column 22 to line 44, column 5)",
+                                                      " (in 'copy_fail.stan', line 25, column 47 to line 46, column 3)",
+                                                      " (in 'copy_fail.stan', line 105, column 8 to column 37)",
+                                                      " (in 'copy_fail.stan', line 106, column 8 to column 41)",
+                                                      " (in 'copy_fail.stan', line 104, column 40 to line 107, column 7)",
+                                                      " (in 'copy_fail.stan', line 108, column 6 to column 37)",
+                                                      " (in 'copy_fail.stan', line 103, column 22 to line 109, column 5)",
+                                                      " (in 'copy_fail.stan', line 102, column 20 to line 110, column 3)",
+                                                      " (in 'copy_fail.stan', line 102, column 2 to line 110, column 3)",
+                                                      " (in 'copy_fail.stan', line 50, column 2 to column 20)",
+                                                      " (in 'copy_fail.stan', line 51, column 2 to column 27)",
+                                                      " (in 'copy_fail.stan', line 52, column 2 to column 44)",
+                                                      " (in 'copy_fail.stan', line 53, column 2 to column 23)",
+                                                      " (in 'copy_fail.stan', line 54, column 2 to column 54)",
+                                                      " (in 'copy_fail.stan', line 58, column 2 to column 38)",
+                                                      " (in 'copy_fail.stan', line 60, column 2 to column 45)",
+                                                      " (in 'copy_fail.stan', line 61, column 2 to column 44)",
+                                                      " (in 'copy_fail.stan', line 8, column 8 to column 17)",
+                                                      " (in 'copy_fail.stan', line 7, column 6 to line 8, column 17)",
+                                                      " (in 'copy_fail.stan', line 5, column 31 to line 10, column 3)",
+                                                      " (in 'copy_fail.stan', line 65, column 4 to column 35)",
+                                                      " (in 'copy_fail.stan', line 64, column 2 to line 65, column 35)",
+                                                      " (in 'copy_fail.stan', line 15, column 6 to column 32)",
+                                                      " (in 'copy_fail.stan', line 19, column 8 to column 17)",
+                                                      " (in 'copy_fail.stan', line 18, column 6 to line 19, column 17)",
+                                                      " (in 'copy_fail.stan', line 13, column 37 to line 20, column 5)",
+                                                      " (in 'copy_fail.stan', line 12, column 30 to line 22, column 3)",
+                                                      " (in 'copy_fail.stan', line 67, column 4 to column 33)",
+                                                      " (in 'copy_fail.stan', line 66, column 2 to line 67, column 33)",
+                                                      " (in 'copy_fail.stan', line 9, column 4 to column 13)",
+                                                      " (in 'copy_fail.stan', line 21, column 4 to column 13)",
+                                                      " (in 'copy_fail.stan', line 30, column 6 to line 43, column 7)",
+                                                      " (in 'copy_fail.stan', line 28, column 4 to line 44, column 5)",
+                                                      " (in 'copy_fail.stan', line 45, column 4 to column 15)"};
+
+
+int
+first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym29__;
+    int lcm_sym28__;
+    int lcm_sym27__;
+    int lcm_sym26__;
+    {
+      lcm_sym27__ = size(y_i);
+      if (logical_gte(lcm_sym27__, 1)) {
+        current_statement__ = 38;
+        if (rvalue(y_i, cons_list(index_uni(1), nil_index_list()), "y_i")) {
+          current_statement__ = 37;
+          return 1;
+        } 
+        for (int k = 2; k <= lcm_sym27__; ++k) {
+          current_statement__ = 38;
+          if (rvalue(y_i, cons_list(index_uni(k), nil_index_list()), "y_i")) {
+            current_statement__ = 37;
+            return k;
+          } }
+      } 
+      current_statement__ = 49;
+      return 0;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct first_capture_functor__ {
+int
+operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+{
+return first_capture(y_i, pstream__);
+}
+};
+
+int
+last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym35__;
+    int lcm_sym34__;
+    int lcm_sym33__;
+    int lcm_sym32__;
+    int lcm_sym31__;
+    int lcm_sym30__;
+    {
+      lcm_sym33__ = (size(y_i) - 1);
+      if (logical_gte(lcm_sym33__, 0)) {
+        int k;
+        k = std::numeric_limits<int>::min();
+        
+        lcm_sym32__ = (size(y_i) - 0);
+        current_statement__ = 44;
+        if (y_i[(lcm_sym32__ - 1)]) {
+          current_statement__ = 43;
+          return lcm_sym32__;
+        } 
+        for (int k_rev = 1; k_rev <= lcm_sym33__; ++k_rev) {
+          int k;
+          k = std::numeric_limits<int>::min();
+          
+          lcm_sym31__ = (size(y_i) - k_rev);
+          current_statement__ = 44;
+          if (y_i[(lcm_sym31__ - 1)]) {
+            current_statement__ = 43;
+            return lcm_sym31__;
+          } }
+      } 
+      current_statement__ = 50;
+      return 0;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct last_capture_functor__ {
+int
+operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+{
+return last_capture(y_i, pstream__);
+}
+};
+
+template <typename T2__, typename T3__>
+Eigen::Matrix<stan::promote_args_t<T2__,
+T3__>, -1, -1>
+prob_uncaptured(const int& nind, const int& n_occasions,
+                const Eigen::Matrix<T2__, -1, -1>& p,
+                const Eigen::Matrix<T3__, -1, -1>& phi,
+                std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<T2__, T3__>;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    double lcm_sym45__;
+    double lcm_sym44__;
+    double lcm_sym43__;
+    double lcm_sym42__;
+    int lcm_sym41__;
+    int lcm_sym40__;
+    int lcm_sym39__;
+    int lcm_sym38__;
+    int lcm_sym37__;
+    int lcm_sym36__;
+    {
+      current_statement__ = 14;
+      validate_non_negative_index("chi", "nind", nind);
+      current_statement__ = 14;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      current_statement__ = 52;
+      if (logical_gte(nind, 1)) {
+        current_statement__ = 15;
+        assign(chi,
+          cons_list(index_uni(1),
+            cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+          "assigning variable chi");
+        lcm_sym39__ = (n_occasions - 1);
+        lcm_sym37__ = logical_gte(lcm_sym39__, 1);
+        if (lcm_sym37__) {
+          int t_curr;
+          t_curr = std::numeric_limits<int>::min();
+          
+          int t_next;
+          t_next = std::numeric_limits<int>::min();
+          
+          lcm_sym41__ = (lcm_sym39__ + 1);
+          current_statement__ = 18;
+          assign(chi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym39__), nil_index_list())),
+            stan::math::fma(
+              (rvalue(phi,
+                 cons_list(index_uni(1),
+                   cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                 "phi") *
+                (1 -
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((lcm_sym41__ - 1)),
+                        nil_index_list())), "p"))),
+              rvalue(chi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(lcm_sym41__), nil_index_list())),
+                "chi"),
+              (1 -
+                rvalue(phi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                  "phi"))), "assigning variable chi");
+          for (int t = 2; t <= lcm_sym39__; ++t) {
+            int t_curr;
+            t_curr = std::numeric_limits<int>::min();
+            
+            lcm_sym38__ = (n_occasions - t);
+            int t_next;
+            t_next = std::numeric_limits<int>::min();
+            
+            lcm_sym40__ = (lcm_sym38__ + 1);
+            current_statement__ = 18;
+            assign(chi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(lcm_sym38__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(1),
+                     cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((lcm_sym40__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(chi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym40__), nil_index_list())),
+                  "chi"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                    "phi"))), "assigning variable chi");}
+        } 
+        for (int i = 2; i <= nind; ++i) {
+          current_statement__ = 15;
+          assign(chi,
+            cons_list(index_uni(i),
+              cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+            "assigning variable chi");
+          current_statement__ = 51;
+          if (lcm_sym37__) {
+            int t_curr;
+            t_curr = std::numeric_limits<int>::min();
+            
+            int t_next;
+            t_next = std::numeric_limits<int>::min();
+            
+            lcm_sym41__ = (lcm_sym39__ + 1);
+            current_statement__ = 18;
+            assign(chi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym39__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(i),
+                     cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((lcm_sym41__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(chi,
+                  cons_list(index_uni(i),
+                    cons_list(index_uni(lcm_sym41__), nil_index_list())),
+                  "chi"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                    "phi"))), "assigning variable chi");
+            for (int t = 2; t <= lcm_sym39__; ++t) {
+              int t_curr;
+              t_curr = std::numeric_limits<int>::min();
+              
+              lcm_sym38__ = (n_occasions - t);
+              int t_next;
+              t_next = std::numeric_limits<int>::min();
+              
+              lcm_sym40__ = (lcm_sym38__ + 1);
+              current_statement__ = 18;
+              assign(chi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(i),
+                       cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((lcm_sym40__ - 1)),
+                            nil_index_list())), "p"))),
+                  rvalue(chi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym40__), nil_index_list())),
+                    "chi"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                      "phi"))), "assigning variable chi");}
+          } }
+      } 
+      current_statement__ = 53;
+      return chi;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct prob_uncaptured_functor__ {
+template <typename T2__, typename T3__>
+Eigen::Matrix<stan::promote_args_t<T2__,
+T3__>, -1, -1>
+operator()(const int& nind, const int& n_occasions,
+           const Eigen::Matrix<T2__, -1, -1>& p,
+           const Eigen::Matrix<T3__, -1, -1>& phi, std::ostream* pstream__)  const 
+{
+return prob_uncaptured(nind, n_occasions, p, phi, pstream__);
+}
+};
+
+class copy_fail_model : 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 lcm_sym158__;
+  int lcm_sym157__;
+  int lcm_sym156__;
+  int lcm_sym155__;
+  int lcm_sym154__;
+  int lcm_sym153__;
+  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 lcm_sym142__;
+  int lcm_sym141__;
+  int pos__;
+  int nind;
+  int n_occasions;
+  std::vector<std::vector<int>> y;
+  int max_age;
+  std::vector<std::vector<int>> x;
+  int n_occ_minus_1;
+  std::vector<int> first;
+  std::vector<int> last;
+ 
+ public:
+  ~copy_fail_model() { }
+  
+  std::string model_name() const { return "copy_fail_model"; }
+  
+  copy_fail_model(stan::io::var_context& context__,
+                  unsigned int random_seed__ = 0,
+                  std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "copy_fail_model_namespace::copy_fail_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","nind","int",
+          context__.to_vec());
+      nind = std::numeric_limits<int>::min();
+      
+      current_statement__ = 29;
+      nind = context__.vals_i("nind")[(1 - 1)];
+      context__.validate_dims("data initialization","n_occasions","int",
+          context__.to_vec());
+      n_occasions = std::numeric_limits<int>::min();
+      
+      current_statement__ = 30;
+      n_occasions = context__.vals_i("n_occasions")[(1 - 1)];
+      current_statement__ = 31;
+      validate_non_negative_index("y", "nind", nind);
+      current_statement__ = 31;
+      validate_non_negative_index("y", "n_occasions", n_occasions);
+      context__.validate_dims("data initialization","y","int",
+          context__.to_vec(nind, n_occasions));
+      y = std::vector<std::vector<int>>(nind, std::vector<int>(n_occasions, std::numeric_limits<int>::min()));
+      
+      {
+        std::vector<int> y_flat__;
+        current_statement__ = 31;
+        assign(y_flat__, nil_index_list(), context__.vals_i("y"),
+          "assigning variable y_flat__");
+        current_statement__ = 31;
+        pos__ = 1;
+        lcm_sym141__ = logical_gte(n_occasions, 1);
+        if (lcm_sym141__) {
+          {
+            lcm_sym142__ = logical_gte(nind, 1);
+            if (lcm_sym142__) {
+              current_statement__ = 31;
+              assign(y,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(1), nil_index_list())),
+                rvalue(y_flat__, cons_list(index_uni(1), nil_index_list()),
+                  "y_flat__"), "assigning variable y");
+              current_statement__ = 31;
+              pos__ = 2;
+              for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+                current_statement__ = 31;
+                assign(y,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(1), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 31;
+                pos__ = (pos__ + 1);}
+            } 
+            for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+              current_statement__ = 31;
+              if (lcm_sym142__) {
+                current_statement__ = 31;
+                assign(y,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 31;
+                pos__ = (pos__ + 1);
+                for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+                  current_statement__ = 31;
+                  assign(y,
+                    cons_list(index_uni(sym2__),
+                      cons_list(index_uni(sym1__), nil_index_list())),
+                    y_flat__[(pos__ - 1)], "assigning variable y");
+                  current_statement__ = 31;
+                  pos__ = (pos__ + 1);}
+              } }
+          }
+        } else {
+          lcm_sym142__ = logical_gte(nind, 1);
+        }
+      }
+      context__.validate_dims("data initialization","max_age","int",
+          context__.to_vec());
+      max_age = std::numeric_limits<int>::min();
+      
+      current_statement__ = 32;
+      max_age = context__.vals_i("max_age")[(1 - 1)];
+      current_statement__ = 33;
+      validate_non_negative_index("x", "nind", nind);
+      lcm_sym144__ = (n_occasions - 1);
+      validate_non_negative_index("x", "(n_occasions - 1)", lcm_sym144__);
+      context__.validate_dims("data initialization","x","int",
+          context__.to_vec(nind, lcm_sym144__));
+      x = std::vector<std::vector<int>>(nind, std::vector<int>(lcm_sym144__, std::numeric_limits<int>::min()));
+      
+      {
+        std::vector<int> x_flat__;
+        current_statement__ = 33;
+        assign(x_flat__, nil_index_list(), context__.vals_i("x"),
+          "assigning variable x_flat__");
+        current_statement__ = 33;
+        pos__ = 1;
+        lcm_sym143__ = logical_gte(lcm_sym144__, 1);
+        if (lcm_sym143__) {
+          current_statement__ = 33;
+          if (lcm_sym142__) {
+            current_statement__ = 33;
+            assign(x,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())),
+              rvalue(x_flat__, cons_list(index_uni(1), nil_index_list()),
+                "x_flat__"), "assigning variable x");
+            current_statement__ = 33;
+            pos__ = 2;
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              current_statement__ = 33;
+              assign(x,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())),
+                x_flat__[(pos__ - 1)], "assigning variable x");
+              current_statement__ = 33;
+              pos__ = (pos__ + 1);}
+          } 
+          for (int sym1__ = 2; sym1__ <= lcm_sym144__; ++sym1__) {
+            current_statement__ = 33;
+            if (lcm_sym142__) {
+              current_statement__ = 33;
+              assign(x,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                x_flat__[(pos__ - 1)], "assigning variable x");
+              current_statement__ = 33;
+              pos__ = (pos__ + 1);
+              for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+                current_statement__ = 33;
+                assign(x,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  x_flat__[(pos__ - 1)], "assigning variable x");
+                current_statement__ = 33;
+                pos__ = (pos__ + 1);}
+            } }
+        } 
+      }
+      n_occ_minus_1 = std::numeric_limits<int>::min();
+      
+      current_statement__ = 34;
+      n_occ_minus_1 = lcm_sym144__;
+      current_statement__ = 35;
+      validate_non_negative_index("first", "nind", nind);
+      first = std::vector<int>(nind, std::numeric_limits<int>::min());
+      
+      current_statement__ = 36;
+      validate_non_negative_index("last", "nind", nind);
+      last = std::vector<int>(nind, std::numeric_limits<int>::min());
+      
+      current_statement__ = 41;
+      if (lcm_sym142__) {
+        int inline_sym17__;
+        int inline_sym19__;
+        inline_sym19__ = std::numeric_limits<int>::min();
+        
+        inline_sym19__ = 0;
+        for (int inline_sym20__ = 1; inline_sym20__ <= 1; ++inline_sym20__) {
+          lcm_sym151__ = size(
+                           rvalue(y,
+                             cons_list(index_uni(1), nil_index_list()), "y"));
+          for (int inline_sym18__ = 1; inline_sym18__ <= lcm_sym151__;
+               ++inline_sym18__) {
+            current_statement__ = 38;
+            if (rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")[
+                (inline_sym18__ - 1)]) {
+              inline_sym19__ = 1;
+              inline_sym17__ = inline_sym18__;
+              break;
+            } }
+          if (inline_sym19__) {
+            break;
+          } 
+          inline_sym19__ = 1;
+          inline_sym17__ = 0;
+          break;}
+        assign(first, cons_list(index_uni(1), nil_index_list()),
+          inline_sym17__, "assigning variable first");
+        for (int i = 2; i <= nind; ++i) {
+          int inline_sym17__;
+          int inline_sym19__;
+          inline_sym19__ = std::numeric_limits<int>::min();
+          
+          inline_sym19__ = 0;
+          for (int inline_sym20__ = 1; inline_sym20__ <= 1; ++inline_sym20__) {
+            lcm_sym150__ = size(
+                             rvalue(y,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "y"));
+            for (int inline_sym18__ = 1; inline_sym18__ <= lcm_sym150__;
+                 ++inline_sym18__) {
+              current_statement__ = 38;
+              if (rvalue(y, cons_list(index_uni(i), nil_index_list()), "y")[
+                  (inline_sym18__ - 1)]) {
+                inline_sym19__ = 1;
+                inline_sym17__ = inline_sym18__;
+                break;
+              } }
+            if (inline_sym19__) {
+              break;
+            } 
+            inline_sym19__ = 1;
+            inline_sym17__ = 0;
+            break;}
+          assign(first, cons_list(index_uni(i), nil_index_list()),
+            inline_sym17__, "assigning variable first");}
+      } 
+      current_statement__ = 48;
+      if (lcm_sym142__) {
+        int inline_sym21__;
+        int inline_sym24__;
+        inline_sym24__ = std::numeric_limits<int>::min();
+        
+        inline_sym24__ = 0;
+        for (int inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) {
+          lcm_sym151__ = size(
+                           rvalue(y,
+                             cons_list(index_uni(1), nil_index_list()), "y"));
+          lcm_sym148__ = (lcm_sym151__ - 1);
+          for (int inline_sym23__ = 0; inline_sym23__ <= lcm_sym148__;
+               ++inline_sym23__) {
+            int inline_sym22__;
+            inline_sym22__ = std::numeric_limits<int>::min();
+            
+            lcm_sym147__ = (lcm_sym151__ - inline_sym23__);
+            inline_sym22__ = lcm_sym147__;
+            current_statement__ = 44;
+            if (rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")[
+                (lcm_sym147__ - 1)]) {
+              inline_sym24__ = 1;
+              inline_sym21__ = lcm_sym147__;
+              break;
+            } }
+          if (inline_sym24__) {
+            break;
+          } 
+          inline_sym24__ = 1;
+          inline_sym21__ = 0;
+          break;}
+        assign(last, cons_list(index_uni(1), nil_index_list()),
+          inline_sym21__, "assigning variable last");
+        for (int i = 2; i <= nind; ++i) {
+          int inline_sym21__;
+          int inline_sym24__;
+          inline_sym24__ = std::numeric_limits<int>::min();
+          
+          inline_sym24__ = 0;
+          for (int inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) {
+            lcm_sym150__ = size(
+                             rvalue(y,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "y"));
+            lcm_sym146__ = (lcm_sym150__ - 1);
+            for (int inline_sym23__ = 0; inline_sym23__ <= lcm_sym146__;
+                 ++inline_sym23__) {
+              int inline_sym22__;
+              inline_sym22__ = std::numeric_limits<int>::min();
+              
+              lcm_sym145__ = (lcm_sym150__ - inline_sym23__);
+              inline_sym22__ = lcm_sym145__;
+              current_statement__ = 44;
+              if (rvalue(y, cons_list(index_uni(i), nil_index_list()), "y")[
+                  (lcm_sym145__ - 1)]) {
+                inline_sym24__ = 1;
+                inline_sym21__ = lcm_sym145__;
+                break;
+              } }
+            if (inline_sym24__) {
+              break;
+            } 
+            inline_sym24__ = 1;
+            inline_sym21__ = 0;
+            break;}
+          assign(last, cons_list(index_uni(i), nil_index_list()),
+            inline_sym21__, "assigning variable last");}
+      } 
+      current_statement__ = 29;
+      current_statement__ = 29;
+      check_greater_or_equal(function__, "nind", nind, 0);
+      current_statement__ = 30;
+      current_statement__ = 30;
+      check_greater_or_equal(function__, "n_occasions", n_occasions, 2);
+      current_statement__ = 31;
+      if (lcm_sym142__) {
+        current_statement__ = 31;
+        if (lcm_sym141__) {
+          current_statement__ = 31;
+          current_statement__ = 31;
+          check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                 rvalue(y,
+                                   cons_list(index_uni(1),
+                                     cons_list(index_uni(1),
+                                       nil_index_list())), "y"), 0);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 31;
+            current_statement__ = 31;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(1),
+                                       cons_list(index_uni(sym2__),
+                                         nil_index_list())), "y"), 0);}
+        } 
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 31;
+          if (lcm_sym141__) {
+            current_statement__ = 31;
+            current_statement__ = 31;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(sym1__),
+                                       cons_list(index_uni(1),
+                                         nil_index_list())), "y"), 0);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 31;
+              current_statement__ = 31;
+              check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                     y[(sym1__ - 1)][(sym2__ - 1)], 0);}
+          } }
+      } 
+      current_statement__ = 31;
+      if (lcm_sym142__) {
+        current_statement__ = 31;
+        if (lcm_sym141__) {
+          current_statement__ = 31;
+          current_statement__ = 31;
+          check_less_or_equal(function__, "y[sym1__, sym2__]",
+                              rvalue(y,
+                                cons_list(index_uni(1),
+                                  cons_list(index_uni(1), nil_index_list())),
+                                "y"), 1);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 31;
+            current_statement__ = 31;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(1),
+                                    cons_list(index_uni(sym2__),
+                                      nil_index_list())), "y"), 1);}
+        } 
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 31;
+          if (lcm_sym141__) {
+            current_statement__ = 31;
+            current_statement__ = 31;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(sym1__),
+                                    cons_list(index_uni(1), nil_index_list())),
+                                  "y"), 1);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 31;
+              current_statement__ = 31;
+              check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                  y[(sym1__ - 1)][(sym2__ - 1)], 1);}
+          } }
+      } 
+      current_statement__ = 32;
+      current_statement__ = 32;
+      check_greater_or_equal(function__, "max_age", max_age, 1);
+      current_statement__ = 33;
+      if (lcm_sym142__) {
+        current_statement__ = 33;
+        if (lcm_sym143__) {
+          current_statement__ = 33;
+          current_statement__ = 33;
+          check_greater_or_equal(function__, "x[sym1__, sym2__]",
+                                 rvalue(x,
+                                   cons_list(index_uni(1),
+                                     cons_list(index_uni(1),
+                                       nil_index_list())), "x"), 0);
+          for (int sym2__ = 2; sym2__ <= lcm_sym144__; ++sym2__) {
+            current_statement__ = 33;
+            current_statement__ = 33;
+            check_greater_or_equal(function__, "x[sym1__, sym2__]",
+                                   rvalue(x,
+                                     cons_list(index_uni(1),
+                                       cons_list(index_uni(sym2__),
+                                         nil_index_list())), "x"), 0);}
+        } 
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 33;
+          if (lcm_sym143__) {
+            current_statement__ = 33;
+            current_statement__ = 33;
+            check_greater_or_equal(function__, "x[sym1__, sym2__]",
+                                   rvalue(x,
+                                     cons_list(index_uni(sym1__),
+                                       cons_list(index_uni(1),
+                                         nil_index_list())), "x"), 0);
+            for (int sym2__ = 2; sym2__ <= lcm_sym144__; ++sym2__) {
+              current_statement__ = 33;
+              current_statement__ = 33;
+              check_greater_or_equal(function__, "x[sym1__, sym2__]",
+                                     x[(sym1__ - 1)][(sym2__ - 1)], 0);}
+          } }
+      } 
+      current_statement__ = 33;
+      if (lcm_sym142__) {
+        current_statement__ = 33;
+        if (lcm_sym143__) {
+          current_statement__ = 33;
+          current_statement__ = 33;
+          check_less_or_equal(function__, "x[sym1__, sym2__]",
+                              rvalue(x,
+                                cons_list(index_uni(1),
+                                  cons_list(index_uni(1), nil_index_list())),
+                                "x"), max_age);
+          for (int sym2__ = 2; sym2__ <= lcm_sym144__; ++sym2__) {
+            current_statement__ = 33;
+            current_statement__ = 33;
+            check_less_or_equal(function__, "x[sym1__, sym2__]",
+                                rvalue(x,
+                                  cons_list(index_uni(1),
+                                    cons_list(index_uni(sym2__),
+                                      nil_index_list())), "x"), max_age);}
+        } 
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 33;
+          if (lcm_sym143__) {
+            current_statement__ = 33;
+            current_statement__ = 33;
+            check_less_or_equal(function__, "x[sym1__, sym2__]",
+                                rvalue(x,
+                                  cons_list(index_uni(sym1__),
+                                    cons_list(index_uni(1), nil_index_list())),
+                                  "x"), max_age);
+            for (int sym2__ = 2; sym2__ <= lcm_sym144__; ++sym2__) {
+              current_statement__ = 33;
+              current_statement__ = 33;
+              check_less_or_equal(function__, "x[sym1__, sym2__]",
+                                  x[(sym1__ - 1)][(sym2__ - 1)], max_age);}
+          } }
+      } 
+      current_statement__ = 35;
+      if (lcm_sym142__) {
+        current_statement__ = 35;
+        current_statement__ = 35;
+        check_greater_or_equal(function__, "first[sym1__]",
+                               rvalue(first,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "first"), 0);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 35;
+          current_statement__ = 35;
+          check_greater_or_equal(function__, "first[sym1__]",
+                                 first[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 35;
+      if (lcm_sym142__) {
+        current_statement__ = 35;
+        current_statement__ = 35;
+        check_less_or_equal(function__, "first[sym1__]",
+                            rvalue(first,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "first"), n_occasions);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 35;
+          current_statement__ = 35;
+          check_less_or_equal(function__, "first[sym1__]",
+                              first[(sym1__ - 1)], n_occasions);}
+      } 
+      current_statement__ = 36;
+      if (lcm_sym142__) {
+        current_statement__ = 36;
+        current_statement__ = 36;
+        check_greater_or_equal(function__, "last[sym1__]",
+                               rvalue(last,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "last"), 0);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 36;
+          current_statement__ = 36;
+          check_greater_or_equal(function__, "last[sym1__]",
+                                 last[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 36;
+      if (lcm_sym142__) {
+        current_statement__ = 36;
+        current_statement__ = 36;
+        check_less_or_equal(function__, "last[sym1__]",
+                            rvalue(last,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "last"), n_occasions);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 36;
+          current_statement__ = 36;
+          check_less_or_equal(function__, "last[sym1__]", last[(sym1__ - 1)],
+                              n_occasions);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      current_statement__ = 2;
+      validate_non_negative_index("beta", "max_age", max_age);
+      num_params_r__ += max_age;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "copy_fail_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      int lcm_sym140__;
+      int lcm_sym139__;
+      int lcm_sym138__;
+      int lcm_sym137__;
+      double lcm_sym136__;
+      double lcm_sym135__;
+      double lcm_sym134__;
+      double lcm_sym133__;
+      double lcm_sym132__;
+      double lcm_sym130__;
+      double lcm_sym128__;
+      double lcm_sym127__;
+      double lcm_sym126__;
+      double lcm_sym125__;
+      double lcm_sym124__;
+      double lcm_sym123__;
+      double lcm_sym122__;
+      double lcm_sym121__;
+      double lcm_sym120__;
+      double lcm_sym119__;
+      double lcm_sym118__;
+      double lcm_sym117__;
+      int lcm_sym116__;
+      int lcm_sym115__;
+      int lcm_sym114__;
+      int lcm_sym113__;
+      int lcm_sym112__;
+      int lcm_sym111__;
+      int lcm_sym110__;
+      int lcm_sym109__;
+      int lcm_sym108__;
+      int lcm_sym107__;
+      int lcm_sym106__;
+      int lcm_sym105__;
+      int lcm_sym104__;
+      int lcm_sym103__;
+      int lcm_sym102__;
+      int lcm_sym101__;
+      int lcm_sym100__;
+      int lcm_sym99__;
+      int lcm_sym98__;
+      int lcm_sym97__;
+      int lcm_sym96__;
+      local_scalar_t__ mean_p;
+      mean_p = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      mean_p = in__.scalar();
+      current_statement__ = 1;
+      if (jacobian__) {
+        current_statement__ = 1;
+        mean_p = stan::math::lub_constrain(mean_p, 0, 1, lp__);
+      } else {
+        current_statement__ = 1;
+        mean_p = stan::math::lub_constrain(mean_p, 0, 1);
+      }
+      current_statement__ = 2;
+      validate_non_negative_index("beta", "max_age", max_age);
+      Eigen::Matrix<local_scalar_t__, -1, 1> beta;
+      beta = Eigen::Matrix<local_scalar_t__, -1, 1>(max_age);
+      stan::math::fill(beta, DUMMY_VAR__);
+      
+      current_statement__ = 2;
+      beta = in__.vector(max_age);
+      current_statement__ = 2;
+      if (logical_gte(max_age, 1)) {
+        current_statement__ = 2;
+        if (jacobian__) {
+          current_statement__ = 2;
+          assign(beta, cons_list(index_uni(1), nil_index_list()),
+            stan::math::lub_constrain(
+              rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+              0, 1, lp__), "assigning variable beta");
+        } else {
+          current_statement__ = 2;
+          assign(beta, cons_list(index_uni(1), nil_index_list()),
+            stan::math::lub_constrain(
+              rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+              0, 1), "assigning variable beta");
+        }
+        for (int sym1__ = 2; sym1__ <= max_age; ++sym1__) {
+          current_statement__ = 2;
+          if (jacobian__) {
+            current_statement__ = 2;
+            assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+              stan::math::lub_constrain(beta[(sym1__ - 1)], 0, 1, lp__),
+              "assigning variable beta");
+          } else {
+            current_statement__ = 2;
+            assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+              stan::math::lub_constrain(beta[(sym1__ - 1)], 0, 1),
+              "assigning variable beta");
+          }}
+      } 
+      current_statement__ = 3;
+      validate_non_negative_index("phi", "nind", nind);
+      lcm_sym108__ = (n_occasions - 1);
+      validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym108__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> phi;
+      phi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, lcm_sym108__);
+      stan::math::fill(phi, DUMMY_VAR__);
+      
+      current_statement__ = 4;
+      validate_non_negative_index("p", "nind", nind);
+      current_statement__ = 4;
+      validate_non_negative_index("p", "n_occ_minus_1", lcm_sym108__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> p;
+      p = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, lcm_sym108__);
+      stan::math::fill(p, DUMMY_VAR__);
+      
+      current_statement__ = 5;
+      validate_non_negative_index("chi", "nind", nind);
+      current_statement__ = 5;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      lcm_sym97__ = logical_gte(nind, 1);
+      if (lcm_sym97__) {
+        lcm_sym138__ = rvalue(first,
+                         cons_list(index_uni(1), nil_index_list()), "first");
+        lcm_sym110__ = (lcm_sym138__ - 1);
+        if (logical_gte(lcm_sym110__, 1)) {
+          current_statement__ = 6;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable phi");
+          current_statement__ = 7;
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable p");
+          for (int t = 2; t <= lcm_sym110__; ++t) {
+            current_statement__ = 6;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 7;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable p");}
+        } 
+        current_statement__ = 12;
+        if (logical_gte(lcm_sym108__, lcm_sym138__)) {
+          current_statement__ = 9;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym138__), nil_index_list())),
+            rvalue(beta,
+              cons_list(
+                index_uni(rvalue(x,
+                            cons_list(index_uni(1),
+                              cons_list(index_uni(lcm_sym138__),
+                                nil_index_list())), "x")), nil_index_list()),
+              "beta"), "assigning variable phi");
+          lcm_sym116__ = (lcm_sym138__ + 1);
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym138__), nil_index_list())), mean_p,
+            "assigning variable p");
+          for (int t = lcm_sym116__; t <= lcm_sym108__; ++t) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())),
+              rvalue(beta,
+                cons_list(
+                  index_uni(rvalue(x,
+                              cons_list(index_uni(1),
+                                cons_list(index_uni(t), nil_index_list())),
+                              "x")), nil_index_list()), "beta"),
+              "assigning variable phi");
+            current_statement__ = 10;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), mean_p,
+              "assigning variable p");}
+        } 
+        for (int i = 2; i <= nind; ++i) {
+          lcm_sym137__ = rvalue(first,
+                           cons_list(index_uni(i), nil_index_list()),
+                           "first");
+          lcm_sym109__ = (lcm_sym137__ - 1);
+          if (logical_gte(lcm_sym109__, 1)) {
+            current_statement__ = 6;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 7;
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable p");
+            for (int t = 2; t <= lcm_sym109__; ++t) {
+              current_statement__ = 6;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable phi");
+              current_statement__ = 7;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable p");}
+          } 
+          current_statement__ = 12;
+          if (logical_gte(lcm_sym108__, lcm_sym137__)) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym137__), nil_index_list())),
+              rvalue(beta,
+                cons_list(
+                  index_uni(rvalue(x,
+                              cons_list(index_uni(i),
+                                cons_list(index_uni(lcm_sym137__),
+                                  nil_index_list())), "x")),
+                  nil_index_list()), "beta"), "assigning variable phi");
+            lcm_sym115__ = (lcm_sym137__ + 1);
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym137__), nil_index_list())),
+              mean_p, "assigning variable p");
+            for (int t = lcm_sym115__; t <= lcm_sym108__; ++t) {
+              current_statement__ = 9;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())),
+                rvalue(beta,
+                  cons_list(
+                    index_uni(rvalue(x,
+                                cons_list(index_uni(i),
+                                  cons_list(index_uni(t), nil_index_list())),
+                                "x")), nil_index_list()), "beta"),
+                "assigning variable phi");
+              current_statement__ = 10;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), mean_p,
+                "assigning variable p");}
+          } }
+      } 
+      Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym9__;
+      int inline_sym15__;
+      inline_sym15__ = std::numeric_limits<int>::min();
+      
+      inline_sym15__ = 0;
+      for (int inline_sym16__ = 1; inline_sym16__ <= 1; ++inline_sym16__) {
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "nind", nind);
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "n_occasions", n_occasions);
+        Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym10__;
+        inline_sym10__ = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+        stan::math::fill(inline_sym10__, DUMMY_VAR__);
+        
+        for (int inline_sym14__ = 1; inline_sym14__ <= nind; ++inline_sym14__) {
+          current_statement__ = 15;
+          assign(inline_sym10__,
+            cons_list(index_uni(inline_sym14__),
+              cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+            "assigning variable inline_sym10__");
+          if (logical_gte(lcm_sym108__, 1)) {
+            int inline_sym11__;
+            inline_sym11__ = std::numeric_limits<int>::min();
+            
+            int inline_sym12__;
+            inline_sym12__ = std::numeric_limits<int>::min();
+            
+            lcm_sym112__ = (lcm_sym108__ + 1);
+            current_statement__ = 18;
+            assign(inline_sym10__,
+              cons_list(index_uni(inline_sym14__),
+                cons_list(index_uni(lcm_sym108__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(inline_sym14__),
+                     cons_list(index_uni(lcm_sym108__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(inline_sym14__),
+                        cons_list(index_uni((lcm_sym112__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(inline_sym10__,
+                  cons_list(index_uni(inline_sym14__),
+                    cons_list(index_uni(lcm_sym112__), nil_index_list())),
+                  "inline_sym10__"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(inline_sym14__),
+                      cons_list(index_uni(lcm_sym108__), nil_index_list())),
+                    "phi"))), "assigning variable inline_sym10__");
+            for (int inline_sym13__ = 2; inline_sym13__ <= lcm_sym108__;
+                 ++inline_sym13__) {
+              int inline_sym11__;
+              inline_sym11__ = std::numeric_limits<int>::min();
+              
+              lcm_sym107__ = (n_occasions - inline_sym13__);
+              int inline_sym12__;
+              inline_sym12__ = std::numeric_limits<int>::min();
+              
+              lcm_sym111__ = (lcm_sym107__ + 1);
+              current_statement__ = 18;
+              assign(inline_sym10__,
+                cons_list(index_uni(inline_sym14__),
+                  cons_list(index_uni(lcm_sym107__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(inline_sym14__),
+                       cons_list(index_uni(lcm_sym107__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(inline_sym14__),
+                          cons_list(index_uni((lcm_sym111__ - 1)),
+                            nil_index_list())), "p"))),
+                  rvalue(inline_sym10__,
+                    cons_list(index_uni(inline_sym14__),
+                      cons_list(index_uni(lcm_sym111__), nil_index_list())),
+                    "inline_sym10__"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(inline_sym14__),
+                        cons_list(index_uni(lcm_sym107__), nil_index_list())),
+                      "phi"))), "assigning variable inline_sym10__");}
+          } 
+          if (inline_sym15__) {
+            break;
+          } }
+        if (inline_sym15__) {
+          break;
+        } 
+        inline_sym15__ = 1;
+        assign(inline_sym9__, nil_index_list(), inline_sym10__,
+          "assigning variable inline_sym9__");
+        break;}
+      assign(chi, nil_index_list(), inline_sym9__, "assigning variable chi");
+      current_statement__ = 3;
+      current_statement__ = 3;
+      check_greater_or_equal(function__, "phi", phi, 0);
+      current_statement__ = 3;
+      current_statement__ = 3;
+      check_less_or_equal(function__, "phi", phi, 1);
+      current_statement__ = 4;
+      current_statement__ = 4;
+      check_greater_or_equal(function__, "p", p, 0);
+      current_statement__ = 4;
+      current_statement__ = 4;
+      check_less_or_equal(function__, "p", p, 1);
+      current_statement__ = 5;
+      current_statement__ = 5;
+      check_greater_or_equal(function__, "chi", inline_sym9__, 0);
+      current_statement__ = 5;
+      current_statement__ = 5;
+      check_less_or_equal(function__, "chi", inline_sym9__, 1);
+      {
+        current_statement__ = 28;
+        if (lcm_sym97__) {
+          lcm_sym138__ = rvalue(first,
+                           cons_list(index_uni(1), nil_index_list()),
+                           "first");
+          if (logical_gt(lcm_sym138__, 0)) {
+            lcm_sym140__ = rvalue(last,
+                             cons_list(index_uni(1), nil_index_list()),
+                             "last");
+            lcm_sym116__ = (lcm_sym138__ + 1);
+            if (logical_gte(lcm_sym140__, lcm_sym116__)) {
+              current_statement__ = 22;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(phi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((lcm_sym116__ - 1)),
+                        nil_index_list())), "phi")));
+              lcm_sym114__ = (lcm_sym116__ + 1);
+              lp_accum__.add(
+                bernoulli_log<propto__>(
+                  rvalue(y,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym116__), nil_index_list())),
+                    "y"),
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((lcm_sym116__ - 1)),
+                        nil_index_list())), "p")));
+              for (int t = lcm_sym114__; t <= lcm_sym140__; ++t) {
+                current_statement__ = 22;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(phi,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((t - 1)), nil_index_list())),
+                      "phi")));
+                current_statement__ = 23;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(
+                    rvalue(y,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(t), nil_index_list())), "y"),
+                    rvalue(p,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((t - 1)), nil_index_list())),
+                      "p")));}
+            } 
+            current_statement__ = 25;
+            lp_accum__.add(
+              bernoulli_log<propto__>(1,
+                rvalue(inline_sym9__,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym140__), nil_index_list())),
+                  "inline_sym9__")));
+          } 
+          for (int i = 2; i <= nind; ++i) {
+            lcm_sym137__ = rvalue(first,
+                             cons_list(index_uni(i), nil_index_list()),
+                             "first");
+            if (logical_gt(lcm_sym137__, 0)) {
+              lcm_sym139__ = rvalue(last,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "last");
+              lcm_sym115__ = (lcm_sym137__ + 1);
+              if (logical_gte(lcm_sym139__, lcm_sym115__)) {
+                current_statement__ = 22;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(phi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((lcm_sym115__ - 1)),
+                          nil_index_list())), "phi")));
+                lcm_sym113__ = (lcm_sym115__ + 1);
+                lp_accum__.add(
+                  bernoulli_log<propto__>(
+                    rvalue(y,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym115__), nil_index_list())),
+                      "y"),
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((lcm_sym115__ - 1)),
+                          nil_index_list())), "p")));
+                for (int t = lcm_sym113__; t <= lcm_sym139__; ++t) {
+                  current_statement__ = 22;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(1,
+                      rvalue(phi,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((t - 1)), nil_index_list())),
+                        "phi")));
+                  current_statement__ = 23;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(
+                      rvalue(y,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni(t), nil_index_list())), "y"),
+                      rvalue(p,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((t - 1)), nil_index_list())),
+                        "p")));}
+              } 
+              current_statement__ = 25;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(inline_sym9__,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym139__), nil_index_list())),
+                    "inline_sym9__")));
+            } }
+        } 
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "copy_fail_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym95__;
+      double lcm_sym94__;
+      double lcm_sym93__;
+      double lcm_sym92__;
+      double lcm_sym91__;
+      double lcm_sym90__;
+      double lcm_sym89__;
+      double lcm_sym88__;
+      double lcm_sym87__;
+      double lcm_sym86__;
+      double lcm_sym85__;
+      double lcm_sym84__;
+      int lcm_sym83__;
+      int lcm_sym82__;
+      double lcm_sym81__;
+      double lcm_sym80__;
+      double lcm_sym79__;
+      double lcm_sym78__;
+      double lcm_sym77__;
+      double lcm_sym76__;
+      double lcm_sym73__;
+      double lcm_sym72__;
+      int lcm_sym71__;
+      int lcm_sym70__;
+      int lcm_sym69__;
+      int lcm_sym68__;
+      int lcm_sym67__;
+      int lcm_sym66__;
+      int lcm_sym65__;
+      int lcm_sym64__;
+      int lcm_sym63__;
+      int lcm_sym62__;
+      int lcm_sym61__;
+      int lcm_sym60__;
+      int lcm_sym59__;
+      int lcm_sym58__;
+      int lcm_sym57__;
+      int lcm_sym56__;
+      int lcm_sym55__;
+      int lcm_sym54__;
+      double mean_p;
+      mean_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mean_p = in__.scalar();
+      current_statement__ = 1;
+      mean_p = stan::math::lub_constrain(mean_p, 0, 1);
+      current_statement__ = 2;
+      validate_non_negative_index("beta", "max_age", max_age);
+      Eigen::Matrix<double, -1, 1> beta;
+      beta = Eigen::Matrix<double, -1, 1>(max_age);
+      stan::math::fill(beta, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 2;
+      beta = in__.vector(max_age);
+      lcm_sym54__ = logical_gte(max_age, 1);
+      if (lcm_sym54__) {
+        current_statement__ = 2;
+        assign(beta, cons_list(index_uni(1), nil_index_list()),
+          stan::math::lub_constrain(
+            rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+            0, 1), "assigning variable beta");
+        for (int sym1__ = 2; sym1__ <= max_age; ++sym1__) {
+          current_statement__ = 2;
+          assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+            stan::math::lub_constrain(beta[(sym1__ - 1)], 0, 1),
+            "assigning variable beta");}
+      } 
+      current_statement__ = 3;
+      validate_non_negative_index("phi", "nind", nind);
+      lcm_sym63__ = (n_occasions - 1);
+      validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym63__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> phi;
+      phi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, lcm_sym63__);
+      stan::math::fill(phi, DUMMY_VAR__);
+      
+      current_statement__ = 4;
+      validate_non_negative_index("p", "nind", nind);
+      current_statement__ = 4;
+      validate_non_negative_index("p", "n_occ_minus_1", lcm_sym63__);
+      Eigen::Matrix<double, -1, -1> p;
+      p = Eigen::Matrix<double, -1, -1>(nind, lcm_sym63__);
+      stan::math::fill(p, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 5;
+      validate_non_negative_index("chi", "nind", nind);
+      current_statement__ = 5;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      vars__.push_back(mean_p);
+      if (lcm_sym54__) {
+        vars__.push_back(
+          rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"));
+        for (int sym1__ = 2; sym1__ <= max_age; ++sym1__) {
+          vars__.push_back(beta[(sym1__ - 1)]);}
+      } 
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      lcm_sym56__ = logical_gte(nind, 1);
+      if (lcm_sym56__) {
+        lcm_sym83__ = rvalue(first,
+                        cons_list(index_uni(1), nil_index_list()), "first");
+        lcm_sym65__ = (lcm_sym83__ - 1);
+        if (logical_gte(lcm_sym65__, 1)) {
+          current_statement__ = 6;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable phi");
+          current_statement__ = 7;
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable p");
+          for (int t = 2; t <= lcm_sym65__; ++t) {
+            current_statement__ = 6;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 7;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable p");}
+        } 
+        current_statement__ = 12;
+        if (logical_gte(lcm_sym63__, lcm_sym83__)) {
+          current_statement__ = 9;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym83__), nil_index_list())),
+            rvalue(beta,
+              cons_list(
+                index_uni(rvalue(x,
+                            cons_list(index_uni(1),
+                              cons_list(index_uni(lcm_sym83__),
+                                nil_index_list())), "x")), nil_index_list()),
+              "beta"), "assigning variable phi");
+          lcm_sym71__ = (lcm_sym83__ + 1);
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym83__), nil_index_list())), mean_p,
+            "assigning variable p");
+          for (int t = lcm_sym71__; t <= lcm_sym63__; ++t) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())),
+              rvalue(beta,
+                cons_list(
+                  index_uni(rvalue(x,
+                              cons_list(index_uni(1),
+                                cons_list(index_uni(t), nil_index_list())),
+                              "x")), nil_index_list()), "beta"),
+              "assigning variable phi");
+            current_statement__ = 10;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), mean_p,
+              "assigning variable p");}
+        } 
+        for (int i = 2; i <= nind; ++i) {
+          lcm_sym82__ = rvalue(first,
+                          cons_list(index_uni(i), nil_index_list()), "first");
+          lcm_sym64__ = (lcm_sym82__ - 1);
+          if (logical_gte(lcm_sym64__, 1)) {
+            current_statement__ = 6;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 7;
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable p");
+            for (int t = 2; t <= lcm_sym64__; ++t) {
+              current_statement__ = 6;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable phi");
+              current_statement__ = 7;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable p");}
+          } 
+          current_statement__ = 12;
+          if (logical_gte(lcm_sym63__, lcm_sym82__)) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym82__), nil_index_list())),
+              rvalue(beta,
+                cons_list(
+                  index_uni(rvalue(x,
+                              cons_list(index_uni(i),
+                                cons_list(index_uni(lcm_sym82__),
+                                  nil_index_list())), "x")),
+                  nil_index_list()), "beta"), "assigning variable phi");
+            lcm_sym70__ = (lcm_sym82__ + 1);
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym82__), nil_index_list())), mean_p,
+              "assigning variable p");
+            for (int t = lcm_sym70__; t <= lcm_sym63__; ++t) {
+              current_statement__ = 9;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())),
+                rvalue(beta,
+                  cons_list(
+                    index_uni(rvalue(x,
+                                cons_list(index_uni(i),
+                                  cons_list(index_uni(t), nil_index_list())),
+                                "x")), nil_index_list()), "beta"),
+                "assigning variable phi");
+              current_statement__ = 10;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), mean_p,
+                "assigning variable p");}
+          } }
+      } 
+      Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym1__;
+      int inline_sym7__;
+      inline_sym7__ = std::numeric_limits<int>::min();
+      
+      lcm_sym57__ = logical_gte(lcm_sym63__, 1);
+      inline_sym7__ = 0;
+      for (int inline_sym8__ = 1; inline_sym8__ <= 1; ++inline_sym8__) {
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "nind", nind);
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "n_occasions", n_occasions);
+        Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym2__;
+        inline_sym2__ = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+        stan::math::fill(inline_sym2__, DUMMY_VAR__);
+        
+        for (int inline_sym6__ = 1; inline_sym6__ <= nind; ++inline_sym6__) {
+          current_statement__ = 15;
+          assign(inline_sym2__,
+            cons_list(index_uni(inline_sym6__),
+              cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+            "assigning variable inline_sym2__");
+          if (lcm_sym57__) {
+            int inline_sym3__;
+            inline_sym3__ = std::numeric_limits<int>::min();
+            
+            int inline_sym4__;
+            inline_sym4__ = std::numeric_limits<int>::min();
+            
+            lcm_sym69__ = (lcm_sym63__ + 1);
+            current_statement__ = 18;
+            assign(inline_sym2__,
+              cons_list(index_uni(inline_sym6__),
+                cons_list(index_uni(lcm_sym63__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(inline_sym6__),
+                     cons_list(index_uni(lcm_sym63__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(inline_sym6__),
+                        cons_list(index_uni((lcm_sym69__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(inline_sym2__,
+                  cons_list(index_uni(inline_sym6__),
+                    cons_list(index_uni(lcm_sym69__), nil_index_list())),
+                  "inline_sym2__"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(inline_sym6__),
+                      cons_list(index_uni(lcm_sym63__), nil_index_list())),
+                    "phi"))), "assigning variable inline_sym2__");
+            for (int inline_sym5__ = 2; inline_sym5__ <= lcm_sym63__;
+                 ++inline_sym5__) {
+              int inline_sym3__;
+              inline_sym3__ = std::numeric_limits<int>::min();
+              
+              lcm_sym62__ = (n_occasions - inline_sym5__);
+              int inline_sym4__;
+              inline_sym4__ = std::numeric_limits<int>::min();
+              
+              lcm_sym68__ = (lcm_sym62__ + 1);
+              current_statement__ = 18;
+              assign(inline_sym2__,
+                cons_list(index_uni(inline_sym6__),
+                  cons_list(index_uni(lcm_sym62__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(inline_sym6__),
+                       cons_list(index_uni(lcm_sym62__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(inline_sym6__),
+                          cons_list(index_uni((lcm_sym68__ - 1)),
+                            nil_index_list())), "p"))),
+                  rvalue(inline_sym2__,
+                    cons_list(index_uni(inline_sym6__),
+                      cons_list(index_uni(lcm_sym68__), nil_index_list())),
+                    "inline_sym2__"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(inline_sym6__),
+                        cons_list(index_uni(lcm_sym62__), nil_index_list())),
+                      "phi"))), "assigning variable inline_sym2__");}
+          } 
+          if (inline_sym7__) {
+            break;
+          } }
+        if (inline_sym7__) {
+          break;
+        } 
+        inline_sym7__ = 1;
+        assign(inline_sym1__, nil_index_list(), inline_sym2__,
+          "assigning variable inline_sym1__");
+        break;}
+      assign(chi, nil_index_list(), inline_sym1__, "assigning variable chi");
+      if (lcm_sym57__) {
+        if (lcm_sym56__) {
+          vars__.push_back(
+            rvalue(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "phi"));
+          for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+            vars__.push_back(
+              rvalue(phi,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "phi"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= lcm_sym63__; ++sym1__) {
+          if (lcm_sym56__) {
+            vars__.push_back(
+              rvalue(phi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())), "phi"));
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              vars__.push_back(
+                rvalue(phi,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())), "phi"));
+            }
+          } }
+      } 
+      if (lcm_sym57__) {
+        if (lcm_sym56__) {
+          vars__.push_back(
+            rvalue(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "p"));
+          for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+            vars__.push_back(
+              rvalue(p,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "p"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= lcm_sym63__; ++sym1__) {
+          if (lcm_sym56__) {
+            vars__.push_back(
+              rvalue(p,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())), "p"));
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              vars__.push_back(
+                rvalue(p,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())), "p"));}
+          } }
+      } 
+      if (logical_gte(n_occasions, 1)) {
+        if (lcm_sym56__) {
+          vars__.push_back(
+            rvalue(inline_sym1__,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "inline_sym1__"));
+          for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+            vars__.push_back(
+              rvalue(inline_sym1__,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())),
+                "inline_sym1__"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          if (lcm_sym56__) {
+            vars__.push_back(
+              rvalue(inline_sym1__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                "inline_sym1__"));
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              vars__.push_back(
+                rvalue(inline_sym1__,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  "inline_sym1__"));}
+          } }
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym53__;
+      double lcm_sym52__;
+      double lcm_sym51__;
+      double lcm_sym50__;
+      int lcm_sym47__;
+      int lcm_sym46__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double mean_p;
+      mean_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mean_p = context__.vals_r("mean_p")[(1 - 1)];
+      current_statement__ = 1;
+      mean_p = stan::math::lub_free(mean_p, 0, 1);
+      current_statement__ = 2;
+      validate_non_negative_index("beta", "max_age", max_age);
+      Eigen::Matrix<double, -1, 1> beta;
+      beta = Eigen::Matrix<double, -1, 1>(max_age);
+      stan::math::fill(beta, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> beta_flat__;
+        current_statement__ = 2;
+        assign(beta_flat__, nil_index_list(), context__.vals_r("beta"),
+          "assigning variable beta_flat__");
+        current_statement__ = 2;
+        pos__ = 1;
+        lcm_sym46__ = logical_gte(max_age, 1);
+        if (lcm_sym46__) {
+          current_statement__ = 2;
+          assign(beta, cons_list(index_uni(1), nil_index_list()),
+            rvalue(beta_flat__, cons_list(index_uni(1), nil_index_list()),
+              "beta_flat__"), "assigning variable beta");
+          current_statement__ = 2;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= max_age; ++sym1__) {
+            current_statement__ = 2;
+            assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+              beta_flat__[(pos__ - 1)], "assigning variable beta");
+            current_statement__ = 2;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 2;
+      if (lcm_sym46__) {
+        current_statement__ = 2;
+        assign(beta, cons_list(index_uni(1), nil_index_list()),
+          stan::math::lub_free(
+            rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+            0, 1), "assigning variable beta");
+        for (int sym1__ = 2; sym1__ <= max_age; ++sym1__) {
+          current_statement__ = 2;
+          assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+            stan::math::lub_free(beta[(sym1__ - 1)], 0, 1),
+            "assigning variable beta");}
+      } 
+      vars__.push_back(mean_p);
+      if (lcm_sym46__) {
+        vars__.push_back(
+          rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"));
+        for (int sym1__ = 2; sym1__ <= max_age; ++sym1__) {
+          vars__.push_back(beta[(sym1__ - 1)]);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("mean_p");
+    names__.push_back("beta");
+    names__.push_back("phi");
+    names__.push_back("p");
+    names__.push_back("chi");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(max_age);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(nind);
+    
+    dims__.push_back(n_occ_minus_1);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(nind);
+    
+    dims__.push_back(n_occ_minus_1);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(nind);
+    
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mean_p");
+    for (int sym172__ = 1; sym172__ <= max_age; ++sym172__) {
+      {
+        param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym172__));
+      }}
+    if (emit_transformed_parameters__) {
+      for (int sym172__ = 1; sym172__ <= n_occ_minus_1; ++sym172__) {
+        {
+          for (int sym173__ = 1; sym173__ <= nind; ++sym173__) {
+            {
+              param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym173__) + '.' + std::to_string(sym172__));
+            }}
+        }}
+      for (int sym172__ = 1; sym172__ <= n_occ_minus_1; ++sym172__) {
+        {
+          for (int sym173__ = 1; sym173__ <= nind; ++sym173__) {
+            {
+              param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym173__) + '.' + std::to_string(sym172__));
+            }}
+        }}
+      for (int sym172__ = 1; sym172__ <= n_occasions; ++sym172__) {
+        {
+          for (int sym173__ = 1; sym173__ <= nind; ++sym173__) {
+            {
+              param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym173__) + '.' + std::to_string(sym172__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mean_p");
+    for (int sym172__ = 1; sym172__ <= max_age; ++sym172__) {
+      {
+        param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym172__));
+      }}
+    if (emit_transformed_parameters__) {
+      for (int sym172__ = 1; sym172__ <= n_occ_minus_1; ++sym172__) {
+        {
+          for (int sym173__ = 1; sym173__ <= nind; ++sym173__) {
+            {
+              param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym173__) + '.' + std::to_string(sym172__));
+            }}
+        }}
+      for (int sym172__ = 1; sym172__ <= n_occ_minus_1; ++sym172__) {
+        {
+          for (int sym173__ = 1; sym173__ <= nind; ++sym173__) {
+            {
+              param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym173__) + '.' + std::to_string(sym172__));
+            }}
+        }}
+      for (int sym172__ = 1; sym172__ <= n_occasions; ++sym172__) {
+        {
+          for (int sym173__ = 1; sym173__ <= nind; ++sym173__) {
+            {
+              param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym173__) + '.' + std::to_string(sym172__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << max_age << "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << max_age << "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef copy_fail_model_namespace::copy_fail_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp dce-fail.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace dce_fail_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'dce-fail.stan', line 18, column 2 to column 22)",
+                                                      " (in 'dce-fail.stan', line 19, column 2 to column 26)",
+                                                      " (in 'dce-fail.stan', line 20, column 2 to column 26)",
+                                                      " (in 'dce-fail.stan', line 21, column 2 to column 28)",
+                                                      " (in 'dce-fail.stan', line 22, column 2 to column 29)",
+                                                      " (in 'dce-fail.stan', line 23, column 2 to column 30)",
+                                                      " (in 'dce-fail.stan', line 25, column 2 to column 11)",
+                                                      " (in 'dce-fail.stan', line 26, column 2 to column 16)",
+                                                      " (in 'dce-fail.stan', line 27, column 2 to column 15)",
+                                                      " (in 'dce-fail.stan', line 28, column 2 to column 22)",
+                                                      " (in 'dce-fail.stan', line 30, column 2 to column 16)",
+                                                      " (in 'dce-fail.stan', line 32, column 2 to column 22)",
+                                                      " (in 'dce-fail.stan', line 33, column 2 to column 22)",
+                                                      " (in 'dce-fail.stan', line 34, column 2 to column 28)",
+                                                      " (in 'dce-fail.stan', line 35, column 2 to column 32)",
+                                                      " (in 'dce-fail.stan', line 37, column 2 to column 24)",
+                                                      " (in 'dce-fail.stan', line 40, column 2 to column 14)",
+                                                      " (in 'dce-fail.stan', line 41, column 2 to column 30)",
+                                                      " (in 'dce-fail.stan', line 43, column 2 to column 23)",
+                                                      " (in 'dce-fail.stan', line 44, column 2 to column 28)",
+                                                      " (in 'dce-fail.stan', line 45, column 2 to column 27)",
+                                                      " (in 'dce-fail.stan', line 46, column 2 to column 34)",
+                                                      " (in 'dce-fail.stan', line 48, column 2 to column 31)",
+                                                      " (in 'dce-fail.stan', line 49, column 2 to column 31)",
+                                                      " (in 'dce-fail.stan', line 50, column 2 to column 37)",
+                                                      " (in 'dce-fail.stan', line 54, column 6 to column 48)",
+                                                      " (in 'dce-fail.stan', line 53, column 4 to line 54, column 48)",
+                                                      " (in 'dce-fail.stan', line 52, column 21 to line 55, column 3)",
+                                                      " (in 'dce-fail.stan', line 52, column 2 to line 55, column 3)",
+                                                      " (in 'dce-fail.stan', line 57, column 2 to column 28)",
+                                                      " (in 'dce-fail.stan', line 60, column 4 to column 64)",
+                                                      " (in 'dce-fail.stan', line 59, column 2 to line 60, column 64)",
+                                                      " (in 'dce-fail.stan', line 62, column 2 to column 43)",
+                                                      " (in 'dce-fail.stan', line 65, column 4 to line 68, column 25)",
+                                                      " (in 'dce-fail.stan', line 64, column 2 to line 68, column 25)",
+                                                      " (in 'dce-fail.stan', line 70, column 2 to column 19)",
+                                                      " (in 'dce-fail.stan', line 2, column 2 to column 17)",
+                                                      " (in 'dce-fail.stan', line 3, column 2 to column 21)",
+                                                      " (in 'dce-fail.stan', line 4, column 2 to column 21)",
+                                                      " (in 'dce-fail.stan', line 5, column 2 to column 24)",
+                                                      " (in 'dce-fail.stan', line 6, column 2 to column 23)",
+                                                      " (in 'dce-fail.stan', line 8, column 2 to column 34)",
+                                                      " (in 'dce-fail.stan', line 9, column 2 to column 33)",
+                                                      " (in 'dce-fail.stan', line 10, column 2 to column 35)",
+                                                      " (in 'dce-fail.stan', line 11, column 2 to column 35)",
+                                                      " (in 'dce-fail.stan', line 12, column 2 to column 46)",
+                                                      " (in 'dce-fail.stan', line 13, column 2 to column 39)",
+                                                      " (in 'dce-fail.stan', line 14, column 2 to column 29)",
+                                                      " (in 'dce-fail.stan', line 15, column 2 to column 25)"};
+
+
+
+class dce_fail_model : public model_base_crtp<dce_fail_model> {
+
+ private:
+  int lcm_sym86__;
+  int lcm_sym85__;
+  double lcm_sym84__;
+  double lcm_sym83__;
+  int lcm_sym82__;
+  int lcm_sym81__;
+  int lcm_sym80__;
+  int lcm_sym79__;
+  int lcm_sym78__;
+  int lcm_sym77__;
+  int lcm_sym76__;
+  int lcm_sym75__;
+  int lcm_sym74__;
+  int lcm_sym73__;
+  int lcm_sym72__;
+  int lcm_sym71__;
+  int lcm_sym70__;
+  int lcm_sym69__;
+  int lcm_sym68__;
+  int pos__;
+  int N;
+  int n_age;
+  int n_edu;
+  int n_region;
+  int n_state;
+  std::vector<int> female;
+  std::vector<int> black;
+  std::vector<int> age;
+  std::vector<int> edu;
+  std::vector<int> region;
+  std::vector<int> state;
+  std::vector<int> y;
+  Eigen::Matrix<double, -1, 1> v_prev;
+ 
+ public:
+  ~dce_fail_model() { }
+  
+  std::string model_name() const { return "dce_fail_model"; }
+  
+  dce_fail_model(stan::io::var_context& context__,
+                 unsigned int random_seed__ = 0,
+                 std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "dce_fail_model_namespace::dce_fail_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","N","int",
+          context__.to_vec());
+      N = std::numeric_limits<int>::min();
+      
+      current_statement__ = 37;
+      N = context__.vals_i("N")[(1 - 1)];
+      context__.validate_dims("data initialization","n_age","int",
+          context__.to_vec());
+      n_age = std::numeric_limits<int>::min();
+      
+      current_statement__ = 38;
+      n_age = context__.vals_i("n_age")[(1 - 1)];
+      context__.validate_dims("data initialization","n_edu","int",
+          context__.to_vec());
+      n_edu = std::numeric_limits<int>::min();
+      
+      current_statement__ = 39;
+      n_edu = context__.vals_i("n_edu")[(1 - 1)];
+      context__.validate_dims("data initialization","n_region","int",
+          context__.to_vec());
+      n_region = std::numeric_limits<int>::min();
+      
+      current_statement__ = 40;
+      n_region = context__.vals_i("n_region")[(1 - 1)];
+      context__.validate_dims("data initialization","n_state","int",
+          context__.to_vec());
+      n_state = std::numeric_limits<int>::min();
+      
+      current_statement__ = 41;
+      n_state = context__.vals_i("n_state")[(1 - 1)];
+      current_statement__ = 42;
+      validate_non_negative_index("female", "N", N);
+      context__.validate_dims("data initialization","female","int",
+          context__.to_vec(N));
+      female = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 42;
+      assign(female, nil_index_list(), context__.vals_i("female"),
+        "assigning variable female");
+      current_statement__ = 43;
+      validate_non_negative_index("black", "N", N);
+      context__.validate_dims("data initialization","black","int",
+          context__.to_vec(N));
+      black = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 43;
+      assign(black, nil_index_list(), context__.vals_i("black"),
+        "assigning variable black");
+      current_statement__ = 44;
+      validate_non_negative_index("age", "N", N);
+      context__.validate_dims("data initialization","age","int",
+          context__.to_vec(N));
+      age = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 44;
+      assign(age, nil_index_list(), context__.vals_i("age"),
+        "assigning variable age");
+      current_statement__ = 45;
+      validate_non_negative_index("edu", "N", N);
+      context__.validate_dims("data initialization","edu","int",
+          context__.to_vec(N));
+      edu = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 45;
+      assign(edu, nil_index_list(), context__.vals_i("edu"),
+        "assigning variable edu");
+      current_statement__ = 46;
+      validate_non_negative_index("region", "n_state", n_state);
+      context__.validate_dims("data initialization","region","int",
+          context__.to_vec(n_state));
+      region = std::vector<int>(n_state, std::numeric_limits<int>::min());
+      
+      current_statement__ = 46;
+      assign(region, nil_index_list(), context__.vals_i("region"),
+        "assigning variable region");
+      current_statement__ = 47;
+      validate_non_negative_index("state", "N", N);
+      context__.validate_dims("data initialization","state","int",
+          context__.to_vec(N));
+      state = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 47;
+      assign(state, nil_index_list(), context__.vals_i("state"),
+        "assigning variable state");
+      current_statement__ = 48;
+      validate_non_negative_index("y", "N", N);
+      context__.validate_dims("data initialization","y","int",
+          context__.to_vec(N));
+      y = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 48;
+      assign(y, nil_index_list(), context__.vals_i("y"),
+        "assigning variable y");
+      current_statement__ = 49;
+      validate_non_negative_index("v_prev", "n_state", n_state);
+      context__.validate_dims("data initialization","v_prev","double",
+          context__.to_vec(n_state));
+      v_prev = Eigen::Matrix<double, -1, 1>(n_state);
+      stan::math::fill(v_prev, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> v_prev_flat__;
+        current_statement__ = 49;
+        assign(v_prev_flat__, nil_index_list(), context__.vals_r("v_prev"),
+          "assigning variable v_prev_flat__");
+        current_statement__ = 49;
+        pos__ = 1;
+        lcm_sym69__ = logical_gte(n_state, 1);
+        if (lcm_sym69__) {
+          current_statement__ = 49;
+          assign(v_prev, cons_list(index_uni(1), nil_index_list()),
+            rvalue(v_prev_flat__, cons_list(index_uni(1), nil_index_list()),
+              "v_prev_flat__"), "assigning variable v_prev");
+          current_statement__ = 49;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= n_state; ++sym1__) {
+            current_statement__ = 49;
+            assign(v_prev, cons_list(index_uni(sym1__), nil_index_list()),
+              v_prev_flat__[(pos__ - 1)], "assigning variable v_prev");
+            current_statement__ = 49;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 37;
+      current_statement__ = 37;
+      check_greater_or_equal(function__, "N", N, 0);
+      current_statement__ = 38;
+      current_statement__ = 38;
+      check_greater_or_equal(function__, "n_age", n_age, 0);
+      current_statement__ = 39;
+      current_statement__ = 39;
+      check_greater_or_equal(function__, "n_edu", n_edu, 0);
+      current_statement__ = 40;
+      current_statement__ = 40;
+      check_greater_or_equal(function__, "n_region", n_region, 0);
+      current_statement__ = 41;
+      current_statement__ = 41;
+      check_greater_or_equal(function__, "n_state", n_state, 0);
+      lcm_sym68__ = logical_gte(N, 1);
+      if (lcm_sym68__) {
+        current_statement__ = 42;
+        current_statement__ = 42;
+        check_greater_or_equal(function__, "female[sym1__]",
+                               rvalue(female,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "female"), 0);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 42;
+          current_statement__ = 42;
+          check_greater_or_equal(function__, "female[sym1__]",
+                                 female[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 42;
+      if (lcm_sym68__) {
+        current_statement__ = 42;
+        current_statement__ = 42;
+        check_less_or_equal(function__, "female[sym1__]",
+                            rvalue(female,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "female"), 1);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 42;
+          current_statement__ = 42;
+          check_less_or_equal(function__, "female[sym1__]",
+                              female[(sym1__ - 1)], 1);}
+      } 
+      current_statement__ = 43;
+      if (lcm_sym68__) {
+        current_statement__ = 43;
+        current_statement__ = 43;
+        check_greater_or_equal(function__, "black[sym1__]",
+                               rvalue(black,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "black"), 0);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 43;
+          current_statement__ = 43;
+          check_greater_or_equal(function__, "black[sym1__]",
+                                 black[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 43;
+      if (lcm_sym68__) {
+        current_statement__ = 43;
+        current_statement__ = 43;
+        check_less_or_equal(function__, "black[sym1__]",
+                            rvalue(black,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "black"), 1);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 43;
+          current_statement__ = 43;
+          check_less_or_equal(function__, "black[sym1__]",
+                              black[(sym1__ - 1)], 1);}
+      } 
+      current_statement__ = 44;
+      if (lcm_sym68__) {
+        current_statement__ = 44;
+        current_statement__ = 44;
+        check_greater_or_equal(function__, "age[sym1__]",
+                               rvalue(age,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "age"), 0);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 44;
+          current_statement__ = 44;
+          check_greater_or_equal(function__, "age[sym1__]",
+                                 age[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 44;
+      if (lcm_sym68__) {
+        current_statement__ = 44;
+        current_statement__ = 44;
+        check_less_or_equal(function__, "age[sym1__]",
+                            rvalue(age,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "age"), n_age);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 44;
+          current_statement__ = 44;
+          check_less_or_equal(function__, "age[sym1__]", age[(sym1__ - 1)],
+                              n_age);}
+      } 
+      current_statement__ = 45;
+      if (lcm_sym68__) {
+        current_statement__ = 45;
+        current_statement__ = 45;
+        check_greater_or_equal(function__, "edu[sym1__]",
+                               rvalue(edu,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "edu"), 0);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 45;
+          current_statement__ = 45;
+          check_greater_or_equal(function__, "edu[sym1__]",
+                                 edu[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 45;
+      if (lcm_sym68__) {
+        current_statement__ = 45;
+        current_statement__ = 45;
+        check_less_or_equal(function__, "edu[sym1__]",
+                            rvalue(edu,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "edu"), n_edu);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 45;
+          current_statement__ = 45;
+          check_less_or_equal(function__, "edu[sym1__]", edu[(sym1__ - 1)],
+                              n_edu);}
+      } 
+      current_statement__ = 46;
+      if (lcm_sym69__) {
+        current_statement__ = 46;
+        current_statement__ = 46;
+        check_greater_or_equal(function__, "region[sym1__]",
+                               rvalue(region,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "region"), 0);
+        for (int sym1__ = 2; sym1__ <= n_state; ++sym1__) {
+          current_statement__ = 46;
+          current_statement__ = 46;
+          check_greater_or_equal(function__, "region[sym1__]",
+                                 region[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 46;
+      if (lcm_sym69__) {
+        current_statement__ = 46;
+        current_statement__ = 46;
+        check_less_or_equal(function__, "region[sym1__]",
+                            rvalue(region,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "region"), n_state);
+        for (int sym1__ = 2; sym1__ <= n_state; ++sym1__) {
+          current_statement__ = 46;
+          current_statement__ = 46;
+          check_less_or_equal(function__, "region[sym1__]",
+                              region[(sym1__ - 1)], n_state);}
+      } 
+      current_statement__ = 47;
+      if (lcm_sym68__) {
+        current_statement__ = 47;
+        current_statement__ = 47;
+        check_greater_or_equal(function__, "state[sym1__]",
+                               rvalue(state,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "state"), 0);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 47;
+          current_statement__ = 47;
+          check_greater_or_equal(function__, "state[sym1__]",
+                                 state[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 47;
+      if (lcm_sym68__) {
+        current_statement__ = 47;
+        current_statement__ = 47;
+        check_less_or_equal(function__, "state[sym1__]",
+                            rvalue(state,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "state"), n_state);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 47;
+          current_statement__ = 47;
+          check_less_or_equal(function__, "state[sym1__]",
+                              state[(sym1__ - 1)], n_state);}
+      } 
+      current_statement__ = 48;
+      if (lcm_sym68__) {
+        current_statement__ = 48;
+        current_statement__ = 48;
+        check_greater_or_equal(function__, "y[sym1__]",
+                               rvalue(y,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "y"), 0);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 48;
+          current_statement__ = 48;
+          check_greater_or_equal(function__, "y[sym1__]", y[(sym1__ - 1)], 0);
+        }
+      } 
+      current_statement__ = 48;
+      if (lcm_sym68__) {
+        current_statement__ = 48;
+        current_statement__ = 48;
+        check_less_or_equal(function__, "y[sym1__]",
+                            rvalue(y,
+                              cons_list(index_uni(1), nil_index_list()), "y"),
+                            1);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 48;
+          current_statement__ = 48;
+          check_less_or_equal(function__, "y[sym1__]", y[(sym1__ - 1)], 1);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      current_statement__ = 12;
+      validate_non_negative_index("b_age", "n_age", n_age);
+      num_params_r__ += n_age;
+      current_statement__ = 13;
+      validate_non_negative_index("b_edu", "n_edu", n_edu);
+      num_params_r__ += n_edu;
+      current_statement__ = 14;
+      validate_non_negative_index("b_region", "n_region", n_region);
+      num_params_r__ += n_region;
+      current_statement__ = 15;
+      validate_non_negative_index("b_age_edu", "n_age", n_age);
+      current_statement__ = 15;
+      validate_non_negative_index("b_age_edu", "n_edu", n_edu);
+      num_params_r__ += n_age * n_edu;
+      current_statement__ = 16;
+      validate_non_negative_index("b_hat", "n_state", n_state);
+      num_params_r__ += n_state;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "dce_fail_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym67__;
+      double lcm_sym66__;
+      double lcm_sym65__;
+      double lcm_sym64__;
+      double lcm_sym63__;
+      double lcm_sym62__;
+      double lcm_sym61__;
+      double lcm_sym60__;
+      double lcm_sym59__;
+      double lcm_sym58__;
+      double lcm_sym57__;
+      double lcm_sym56__;
+      double lcm_sym55__;
+      double lcm_sym54__;
+      double lcm_sym53__;
+      double lcm_sym52__;
+      double lcm_sym51__;
+      double lcm_sym50__;
+      int lcm_sym49__;
+      int lcm_sym48__;
+      int lcm_sym47__;
+      int lcm_sym46__;
+      local_scalar_t__ sigma;
+      sigma = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      sigma = in__.scalar();
+      current_statement__ = 1;
+      if (jacobian__) {
+        current_statement__ = 1;
+        sigma = stan::math::lb_constrain(sigma, 0, lp__);
+      } else {
+        current_statement__ = 1;
+        sigma = stan::math::lb_constrain(sigma, 0);
+      }
+      local_scalar_t__ sigma_age;
+      sigma_age = DUMMY_VAR__;
+      
+      current_statement__ = 2;
+      sigma_age = in__.scalar();
+      current_statement__ = 2;
+      if (jacobian__) {
+        current_statement__ = 2;
+        sigma_age = stan::math::lb_constrain(sigma_age, 0, lp__);
+      } else {
+        current_statement__ = 2;
+        sigma_age = stan::math::lb_constrain(sigma_age, 0);
+      }
+      local_scalar_t__ sigma_edu;
+      sigma_edu = DUMMY_VAR__;
+      
+      current_statement__ = 3;
+      sigma_edu = in__.scalar();
+      current_statement__ = 3;
+      if (jacobian__) {
+        current_statement__ = 3;
+        sigma_edu = stan::math::lb_constrain(sigma_edu, 0, lp__);
+      } else {
+        current_statement__ = 3;
+        sigma_edu = stan::math::lb_constrain(sigma_edu, 0);
+      }
+      local_scalar_t__ sigma_state;
+      sigma_state = DUMMY_VAR__;
+      
+      current_statement__ = 4;
+      sigma_state = in__.scalar();
+      current_statement__ = 4;
+      if (jacobian__) {
+        current_statement__ = 4;
+        sigma_state = stan::math::lb_constrain(sigma_state, 0, lp__);
+      } else {
+        current_statement__ = 4;
+        sigma_state = stan::math::lb_constrain(sigma_state, 0);
+      }
+      local_scalar_t__ sigma_region;
+      sigma_region = DUMMY_VAR__;
+      
+      current_statement__ = 5;
+      sigma_region = in__.scalar();
+      current_statement__ = 5;
+      if (jacobian__) {
+        current_statement__ = 5;
+        sigma_region = stan::math::lb_constrain(sigma_region, 0, lp__);
+      } else {
+        current_statement__ = 5;
+        sigma_region = stan::math::lb_constrain(sigma_region, 0);
+      }
+      local_scalar_t__ sigma_age_edu;
+      sigma_age_edu = DUMMY_VAR__;
+      
+      current_statement__ = 6;
+      sigma_age_edu = in__.scalar();
+      current_statement__ = 6;
+      if (jacobian__) {
+        current_statement__ = 6;
+        sigma_age_edu = stan::math::lb_constrain(sigma_age_edu, 0, lp__);
+      } else {
+        current_statement__ = 6;
+        sigma_age_edu = stan::math::lb_constrain(sigma_age_edu, 0);
+      }
+      local_scalar_t__ b_0;
+      b_0 = DUMMY_VAR__;
+      
+      current_statement__ = 7;
+      b_0 = in__.scalar();
+      local_scalar_t__ b_female;
+      b_female = DUMMY_VAR__;
+      
+      current_statement__ = 8;
+      b_female = in__.scalar();
+      local_scalar_t__ b_black;
+      b_black = DUMMY_VAR__;
+      
+      current_statement__ = 9;
+      b_black = in__.scalar();
+      local_scalar_t__ b_female_black;
+      b_female_black = DUMMY_VAR__;
+      
+      current_statement__ = 10;
+      b_female_black = in__.scalar();
+      local_scalar_t__ b_v_prev;
+      b_v_prev = DUMMY_VAR__;
+      
+      current_statement__ = 11;
+      b_v_prev = in__.scalar();
+      current_statement__ = 12;
+      validate_non_negative_index("b_age", "n_age", n_age);
+      Eigen::Matrix<local_scalar_t__, -1, 1> b_age;
+      b_age = Eigen::Matrix<local_scalar_t__, -1, 1>(n_age);
+      stan::math::fill(b_age, DUMMY_VAR__);
+      
+      current_statement__ = 12;
+      b_age = in__.vector(n_age);
+      current_statement__ = 13;
+      validate_non_negative_index("b_edu", "n_edu", n_edu);
+      Eigen::Matrix<local_scalar_t__, -1, 1> b_edu;
+      b_edu = Eigen::Matrix<local_scalar_t__, -1, 1>(n_edu);
+      stan::math::fill(b_edu, DUMMY_VAR__);
+      
+      current_statement__ = 13;
+      b_edu = in__.vector(n_edu);
+      current_statement__ = 14;
+      validate_non_negative_index("b_region", "n_region", n_region);
+      Eigen::Matrix<local_scalar_t__, -1, 1> b_region;
+      b_region = Eigen::Matrix<local_scalar_t__, -1, 1>(n_region);
+      stan::math::fill(b_region, DUMMY_VAR__);
+      
+      current_statement__ = 14;
+      b_region = in__.vector(n_region);
+      current_statement__ = 15;
+      validate_non_negative_index("b_age_edu", "n_age", n_age);
+      current_statement__ = 15;
+      validate_non_negative_index("b_age_edu", "n_edu", n_edu);
+      Eigen::Matrix<local_scalar_t__, -1, -1> b_age_edu;
+      b_age_edu = Eigen::Matrix<local_scalar_t__, -1, -1>(n_age, n_edu);
+      stan::math::fill(b_age_edu, DUMMY_VAR__);
+      
+      current_statement__ = 15;
+      b_age_edu = in__.matrix(n_age, n_edu);
+      current_statement__ = 16;
+      validate_non_negative_index("b_hat", "n_state", n_state);
+      Eigen::Matrix<local_scalar_t__, -1, 1> b_hat;
+      b_hat = Eigen::Matrix<local_scalar_t__, -1, 1>(n_state);
+      stan::math::fill(b_hat, DUMMY_VAR__);
+      
+      current_statement__ = 16;
+      b_hat = in__.vector(n_state);
+      {
+        current_statement__ = 17;
+        validate_non_negative_index("p", "N", N);
+        Eigen::Matrix<local_scalar_t__, -1, 1> p;
+        p = Eigen::Matrix<local_scalar_t__, -1, 1>(N);
+        stan::math::fill(p, DUMMY_VAR__);
+        
+        current_statement__ = 18;
+        validate_non_negative_index("b_state_hat", "n_state", n_state);
+        Eigen::Matrix<local_scalar_t__, -1, 1> b_state_hat;
+        b_state_hat = Eigen::Matrix<local_scalar_t__, -1, 1>(n_state);
+        stan::math::fill(b_state_hat, DUMMY_VAR__);
+        
+        current_statement__ = 19;
+        lp_accum__.add(normal_log<propto__>(b_0, 0, 100));
+        current_statement__ = 20;
+        lp_accum__.add(normal_log<propto__>(b_female, 0, 100));
+        current_statement__ = 21;
+        lp_accum__.add(normal_log<propto__>(b_black, 0, 100));
+        current_statement__ = 22;
+        lp_accum__.add(normal_log<propto__>(b_female_black, 0, 100));
+        current_statement__ = 23;
+        lp_accum__.add(normal_log<propto__>(b_age, 0, sigma_age));
+        current_statement__ = 24;
+        lp_accum__.add(normal_log<propto__>(b_edu, 0, sigma_edu));
+        current_statement__ = 25;
+        lp_accum__.add(normal_log<propto__>(b_region, 0, sigma_region));
+        current_statement__ = 29;
+        if (logical_gte(n_age, 1)) {
+          lcm_sym48__ = logical_gte(n_edu, 1);
+          if (lcm_sym48__) {
+            current_statement__ = 26;
+            lp_accum__.add(
+              normal_log<propto__>(
+                rvalue(b_age_edu,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(1), nil_index_list())), "b_age_edu"),
+                0, sigma_age_edu));
+            for (int i = 2; i <= n_edu; ++i) {
+              current_statement__ = 26;
+              lp_accum__.add(
+                normal_log<propto__>(
+                  rvalue(b_age_edu,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(i), nil_index_list())),
+                    "b_age_edu"), 0, sigma_age_edu));}
+          } 
+          for (int j = 2; j <= n_age; ++j) {
+            current_statement__ = 27;
+            if (lcm_sym48__) {
+              current_statement__ = 26;
+              lp_accum__.add(
+                normal_log<propto__>(
+                  rvalue(b_age_edu,
+                    cons_list(index_uni(j),
+                      cons_list(index_uni(1), nil_index_list())),
+                    "b_age_edu"), 0, sigma_age_edu));
+              for (int i = 2; i <= n_edu; ++i) {
+                current_statement__ = 26;
+                lp_accum__.add(
+                  normal_log<propto__>(
+                    rvalue(b_age_edu,
+                      cons_list(index_uni(j),
+                        cons_list(index_uni(i), nil_index_list())),
+                      "b_age_edu"), 0, sigma_age_edu));}
+            } }
+        } 
+        current_statement__ = 30;
+        lp_accum__.add(normal_log<propto__>(b_v_prev, 0, 100));
+        current_statement__ = 32;
+        if (logical_gte(n_state, 1)) {
+          current_statement__ = 31;
+          assign(b_state_hat, cons_list(index_uni(1), nil_index_list()),
+            stan::math::fma(b_v_prev,
+              rvalue(v_prev, cons_list(index_uni(1), nil_index_list()),
+                "v_prev"),
+              rvalue(b_region,
+                cons_list(
+                  index_uni(rvalue(region,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "region")), nil_index_list()), "b_region")),
+            "assigning variable b_state_hat");
+          for (int j = 2; j <= n_state; ++j) {
+            current_statement__ = 31;
+            assign(b_state_hat, cons_list(index_uni(j), nil_index_list()),
+              stan::math::fma(b_v_prev,
+                rvalue(v_prev, cons_list(index_uni(j), nil_index_list()),
+                  "v_prev"),
+                rvalue(b_region,
+                  cons_list(
+                    index_uni(rvalue(region,
+                                cons_list(index_uni(j), nil_index_list()),
+                                "region")), nil_index_list()), "b_region")),
+              "assigning variable b_state_hat");}
+        } 
+        current_statement__ = 33;
+        lp_accum__.add(normal_log<propto__>(b_hat, b_state_hat, sigma_state));
+        current_statement__ = 35;
+        if (logical_gte(N, 1)) {
+          current_statement__ = 34;
+          assign(p, cons_list(index_uni(1), nil_index_list()),
+            stan::math::fmax(0,
+              stan::math::fmin(1,
+                inv_logit(
+                  ((((stan::math::fma(
+                        (b_female_black *
+                          rvalue(female,
+                            cons_list(index_uni(1), nil_index_list()),
+                            "female")),
+                        rvalue(black,
+                          cons_list(index_uni(1), nil_index_list()), "black"),
+                        stan::math::fma(b_black,
+                          rvalue(black,
+                            cons_list(index_uni(1), nil_index_list()),
+                            "black"),
+                          stan::math::fma(b_female,
+                            rvalue(female,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "female"), b_0))) +
+                       rvalue(b_age,
+                         cons_list(
+                           index_uni(rvalue(age,
+                                       cons_list(index_uni(1),
+                                         nil_index_list()), "age")),
+                           nil_index_list()), "b_age")) +
+                      rvalue(b_edu,
+                        cons_list(
+                          index_uni(rvalue(edu,
+                                      cons_list(index_uni(1),
+                                        nil_index_list()), "edu")),
+                          nil_index_list()), "b_edu")) +
+                     rvalue(b_age_edu,
+                       cons_list(
+                         index_uni(rvalue(age,
+                                     cons_list(index_uni(1),
+                                       nil_index_list()), "age")),
+                         cons_list(
+                           index_uni(rvalue(edu,
+                                       cons_list(index_uni(1),
+                                         nil_index_list()), "edu")),
+                           nil_index_list())), "b_age_edu")) +
+                    rvalue(b_hat,
+                      cons_list(
+                        index_uni(rvalue(state,
+                                    cons_list(index_uni(1), nil_index_list()),
+                                    "state")), nil_index_list()), "b_hat"))))),
+            "assigning variable p");
+          for (int i = 2; i <= N; ++i) {
+            current_statement__ = 34;
+            assign(p, cons_list(index_uni(i), nil_index_list()),
+              stan::math::fmax(0,
+                stan::math::fmin(1,
+                  inv_logit(
+                    ((((stan::math::fma(
+                          (b_female_black *
+                            rvalue(female,
+                              cons_list(index_uni(i), nil_index_list()),
+                              "female")),
+                          rvalue(black,
+                            cons_list(index_uni(i), nil_index_list()),
+                            "black"),
+                          stan::math::fma(b_black,
+                            rvalue(black,
+                              cons_list(index_uni(i), nil_index_list()),
+                              "black"),
+                            stan::math::fma(b_female,
+                              rvalue(female,
+                                cons_list(index_uni(i), nil_index_list()),
+                                "female"), b_0))) +
+                         rvalue(b_age,
+                           cons_list(
+                             index_uni(rvalue(age,
+                                         cons_list(index_uni(i),
+                                           nil_index_list()), "age")),
+                             nil_index_list()), "b_age")) +
+                        rvalue(b_edu,
+                          cons_list(
+                            index_uni(rvalue(edu,
+                                        cons_list(index_uni(i),
+                                          nil_index_list()), "edu")),
+                            nil_index_list()), "b_edu")) +
+                       rvalue(b_age_edu,
+                         cons_list(
+                           index_uni(rvalue(age,
+                                       cons_list(index_uni(i),
+                                         nil_index_list()), "age")),
+                           cons_list(
+                             index_uni(rvalue(edu,
+                                         cons_list(index_uni(i),
+                                           nil_index_list()), "edu")),
+                             nil_index_list())), "b_age_edu")) +
+                      rvalue(b_hat,
+                        cons_list(
+                          index_uni(rvalue(state,
+                                      cons_list(index_uni(i),
+                                        nil_index_list()), "state")),
+                          nil_index_list()), "b_hat"))))),
+              "assigning variable p");}
+        } 
+        current_statement__ = 36;
+        lp_accum__.add(bernoulli_log<propto__>(y, p));
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "dce_fail_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym45__;
+      double lcm_sym44__;
+      double lcm_sym43__;
+      double lcm_sym42__;
+      double lcm_sym41__;
+      double lcm_sym40__;
+      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 lcm_sym31__;
+      int lcm_sym30__;
+      int lcm_sym29__;
+      int lcm_sym28__;
+      double sigma;
+      sigma = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      sigma = in__.scalar();
+      current_statement__ = 1;
+      sigma = stan::math::lb_constrain(sigma, 0);
+      double sigma_age;
+      sigma_age = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      sigma_age = in__.scalar();
+      current_statement__ = 2;
+      sigma_age = stan::math::lb_constrain(sigma_age, 0);
+      double sigma_edu;
+      sigma_edu = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      sigma_edu = in__.scalar();
+      current_statement__ = 3;
+      sigma_edu = stan::math::lb_constrain(sigma_edu, 0);
+      double sigma_state;
+      sigma_state = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      sigma_state = in__.scalar();
+      current_statement__ = 4;
+      sigma_state = stan::math::lb_constrain(sigma_state, 0);
+      double sigma_region;
+      sigma_region = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 5;
+      sigma_region = in__.scalar();
+      current_statement__ = 5;
+      sigma_region = stan::math::lb_constrain(sigma_region, 0);
+      double sigma_age_edu;
+      sigma_age_edu = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 6;
+      sigma_age_edu = in__.scalar();
+      current_statement__ = 6;
+      sigma_age_edu = stan::math::lb_constrain(sigma_age_edu, 0);
+      double b_0;
+      b_0 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 7;
+      b_0 = in__.scalar();
+      double b_female;
+      b_female = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 8;
+      b_female = in__.scalar();
+      double b_black;
+      b_black = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 9;
+      b_black = in__.scalar();
+      double b_female_black;
+      b_female_black = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 10;
+      b_female_black = in__.scalar();
+      double b_v_prev;
+      b_v_prev = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 11;
+      b_v_prev = in__.scalar();
+      current_statement__ = 12;
+      validate_non_negative_index("b_age", "n_age", n_age);
+      Eigen::Matrix<double, -1, 1> b_age;
+      b_age = Eigen::Matrix<double, -1, 1>(n_age);
+      stan::math::fill(b_age, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 12;
+      b_age = in__.vector(n_age);
+      current_statement__ = 13;
+      validate_non_negative_index("b_edu", "n_edu", n_edu);
+      Eigen::Matrix<double, -1, 1> b_edu;
+      b_edu = Eigen::Matrix<double, -1, 1>(n_edu);
+      stan::math::fill(b_edu, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 13;
+      b_edu = in__.vector(n_edu);
+      current_statement__ = 14;
+      validate_non_negative_index("b_region", "n_region", n_region);
+      Eigen::Matrix<double, -1, 1> b_region;
+      b_region = Eigen::Matrix<double, -1, 1>(n_region);
+      stan::math::fill(b_region, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 14;
+      b_region = in__.vector(n_region);
+      current_statement__ = 15;
+      validate_non_negative_index("b_age_edu", "n_age", n_age);
+      current_statement__ = 15;
+      validate_non_negative_index("b_age_edu", "n_edu", n_edu);
+      Eigen::Matrix<double, -1, -1> b_age_edu;
+      b_age_edu = Eigen::Matrix<double, -1, -1>(n_age, n_edu);
+      stan::math::fill(b_age_edu, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 15;
+      b_age_edu = in__.matrix(n_age, n_edu);
+      current_statement__ = 16;
+      validate_non_negative_index("b_hat", "n_state", n_state);
+      Eigen::Matrix<double, -1, 1> b_hat;
+      b_hat = Eigen::Matrix<double, -1, 1>(n_state);
+      stan::math::fill(b_hat, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 16;
+      b_hat = in__.vector(n_state);
+      vars__.push_back(sigma);
+      vars__.push_back(sigma_age);
+      vars__.push_back(sigma_edu);
+      vars__.push_back(sigma_state);
+      vars__.push_back(sigma_region);
+      vars__.push_back(sigma_age_edu);
+      vars__.push_back(b_0);
+      vars__.push_back(b_female);
+      vars__.push_back(b_black);
+      vars__.push_back(b_female_black);
+      vars__.push_back(b_v_prev);
+      lcm_sym28__ = logical_gte(n_age, 1);
+      if (lcm_sym28__) {
+        vars__.push_back(
+          rvalue(b_age, cons_list(index_uni(1), nil_index_list()), "b_age"));
+        for (int sym1__ = 2; sym1__ <= n_age; ++sym1__) {
+          vars__.push_back(b_age[(sym1__ - 1)]);}
+      } 
+      lcm_sym29__ = logical_gte(n_edu, 1);
+      if (lcm_sym29__) {
+        vars__.push_back(
+          rvalue(b_edu, cons_list(index_uni(1), nil_index_list()), "b_edu"));
+        for (int sym1__ = 2; sym1__ <= n_edu; ++sym1__) {
+          vars__.push_back(b_edu[(sym1__ - 1)]);}
+      } 
+      if (logical_gte(n_region, 1)) {
+        vars__.push_back(
+          rvalue(b_region, cons_list(index_uni(1), nil_index_list()),
+            "b_region"));
+        for (int sym1__ = 2; sym1__ <= n_region; ++sym1__) {
+          vars__.push_back(b_region[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym29__) {
+        if (lcm_sym28__) {
+          vars__.push_back(
+            rvalue(b_age_edu,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "b_age_edu"));
+          for (int sym2__ = 2; sym2__ <= n_age; ++sym2__) {
+            vars__.push_back(
+              rvalue(b_age_edu,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "b_age_edu"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= n_edu; ++sym1__) {
+          if (lcm_sym28__) {
+            vars__.push_back(
+              rvalue(b_age_edu,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                "b_age_edu"));
+            for (int sym2__ = 2; sym2__ <= n_age; ++sym2__) {
+              vars__.push_back(
+                rvalue(b_age_edu,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  "b_age_edu"));}
+          } }
+      } 
+      if (logical_gte(n_state, 1)) {
+        vars__.push_back(
+          rvalue(b_hat, cons_list(index_uni(1), nil_index_list()), "b_hat"));
+        for (int sym1__ = 2; sym1__ <= n_state; ++sym1__) {
+          vars__.push_back(b_hat[(sym1__ - 1)]);}
+      } 
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym27__;
+      double lcm_sym26__;
+      double lcm_sym25__;
+      double lcm_sym24__;
+      double lcm_sym23__;
+      double lcm_sym22__;
+      double lcm_sym21__;
+      double lcm_sym20__;
+      double lcm_sym19__;
+      double lcm_sym18__;
+      double lcm_sym17__;
+      double lcm_sym16__;
+      double lcm_sym15__;
+      double lcm_sym14__;
+      double lcm_sym13__;
+      double lcm_sym12__;
+      double lcm_sym11__;
+      double lcm_sym10__;
+      double lcm_sym9__;
+      double lcm_sym8__;
+      double lcm_sym7__;
+      double lcm_sym6__;
+      int lcm_sym5__;
+      int lcm_sym4__;
+      int lcm_sym3__;
+      int lcm_sym2__;
+      int lcm_sym1__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double sigma;
+      sigma = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      sigma = context__.vals_r("sigma")[(1 - 1)];
+      current_statement__ = 1;
+      sigma = stan::math::lb_free(sigma, 0);
+      double sigma_age;
+      sigma_age = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      sigma_age = context__.vals_r("sigma_age")[(1 - 1)];
+      current_statement__ = 2;
+      sigma_age = stan::math::lb_free(sigma_age, 0);
+      double sigma_edu;
+      sigma_edu = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      sigma_edu = context__.vals_r("sigma_edu")[(1 - 1)];
+      current_statement__ = 3;
+      sigma_edu = stan::math::lb_free(sigma_edu, 0);
+      double sigma_state;
+      sigma_state = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      sigma_state = context__.vals_r("sigma_state")[(1 - 1)];
+      current_statement__ = 4;
+      sigma_state = stan::math::lb_free(sigma_state, 0);
+      double sigma_region;
+      sigma_region = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 5;
+      sigma_region = context__.vals_r("sigma_region")[(1 - 1)];
+      current_statement__ = 5;
+      sigma_region = stan::math::lb_free(sigma_region, 0);
+      double sigma_age_edu;
+      sigma_age_edu = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 6;
+      sigma_age_edu = context__.vals_r("sigma_age_edu")[(1 - 1)];
+      current_statement__ = 6;
+      sigma_age_edu = stan::math::lb_free(sigma_age_edu, 0);
+      double b_0;
+      b_0 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 7;
+      b_0 = context__.vals_r("b_0")[(1 - 1)];
+      double b_female;
+      b_female = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 8;
+      b_female = context__.vals_r("b_female")[(1 - 1)];
+      double b_black;
+      b_black = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 9;
+      b_black = context__.vals_r("b_black")[(1 - 1)];
+      double b_female_black;
+      b_female_black = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 10;
+      b_female_black = context__.vals_r("b_female_black")[(1 - 1)];
+      double b_v_prev;
+      b_v_prev = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 11;
+      b_v_prev = context__.vals_r("b_v_prev")[(1 - 1)];
+      current_statement__ = 12;
+      validate_non_negative_index("b_age", "n_age", n_age);
+      Eigen::Matrix<double, -1, 1> b_age;
+      b_age = Eigen::Matrix<double, -1, 1>(n_age);
+      stan::math::fill(b_age, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> b_age_flat__;
+        current_statement__ = 12;
+        assign(b_age_flat__, nil_index_list(), context__.vals_r("b_age"),
+          "assigning variable b_age_flat__");
+        current_statement__ = 12;
+        pos__ = 1;
+        lcm_sym1__ = logical_gte(n_age, 1);
+        if (lcm_sym1__) {
+          current_statement__ = 12;
+          assign(b_age, cons_list(index_uni(1), nil_index_list()),
+            rvalue(b_age_flat__, cons_list(index_uni(1), nil_index_list()),
+              "b_age_flat__"), "assigning variable b_age");
+          current_statement__ = 12;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= n_age; ++sym1__) {
+            current_statement__ = 12;
+            assign(b_age, cons_list(index_uni(sym1__), nil_index_list()),
+              b_age_flat__[(pos__ - 1)], "assigning variable b_age");
+            current_statement__ = 12;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 13;
+      validate_non_negative_index("b_edu", "n_edu", n_edu);
+      Eigen::Matrix<double, -1, 1> b_edu;
+      b_edu = Eigen::Matrix<double, -1, 1>(n_edu);
+      stan::math::fill(b_edu, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> b_edu_flat__;
+        current_statement__ = 13;
+        assign(b_edu_flat__, nil_index_list(), context__.vals_r("b_edu"),
+          "assigning variable b_edu_flat__");
+        current_statement__ = 13;
+        pos__ = 1;
+        lcm_sym2__ = logical_gte(n_edu, 1);
+        if (lcm_sym2__) {
+          current_statement__ = 13;
+          assign(b_edu, cons_list(index_uni(1), nil_index_list()),
+            rvalue(b_edu_flat__, cons_list(index_uni(1), nil_index_list()),
+              "b_edu_flat__"), "assigning variable b_edu");
+          current_statement__ = 13;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= n_edu; ++sym1__) {
+            current_statement__ = 13;
+            assign(b_edu, cons_list(index_uni(sym1__), nil_index_list()),
+              b_edu_flat__[(pos__ - 1)], "assigning variable b_edu");
+            current_statement__ = 13;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 14;
+      validate_non_negative_index("b_region", "n_region", n_region);
+      Eigen::Matrix<double, -1, 1> b_region;
+      b_region = Eigen::Matrix<double, -1, 1>(n_region);
+      stan::math::fill(b_region, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> b_region_flat__;
+        current_statement__ = 14;
+        assign(b_region_flat__, nil_index_list(),
+          context__.vals_r("b_region"), "assigning variable b_region_flat__");
+        current_statement__ = 14;
+        pos__ = 1;
+        lcm_sym3__ = logical_gte(n_region, 1);
+        if (lcm_sym3__) {
+          current_statement__ = 14;
+          assign(b_region, cons_list(index_uni(1), nil_index_list()),
+            rvalue(b_region_flat__,
+              cons_list(index_uni(1), nil_index_list()), "b_region_flat__"),
+            "assigning variable b_region");
+          current_statement__ = 14;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= n_region; ++sym1__) {
+            current_statement__ = 14;
+            assign(b_region, cons_list(index_uni(sym1__), nil_index_list()),
+              b_region_flat__[(pos__ - 1)], "assigning variable b_region");
+            current_statement__ = 14;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 15;
+      validate_non_negative_index("b_age_edu", "n_age", n_age);
+      current_statement__ = 15;
+      validate_non_negative_index("b_age_edu", "n_edu", n_edu);
+      Eigen::Matrix<double, -1, -1> b_age_edu;
+      b_age_edu = Eigen::Matrix<double, -1, -1>(n_age, n_edu);
+      stan::math::fill(b_age_edu, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> b_age_edu_flat__;
+        current_statement__ = 15;
+        assign(b_age_edu_flat__, nil_index_list(),
+          context__.vals_r("b_age_edu"),
+          "assigning variable b_age_edu_flat__");
+        current_statement__ = 15;
+        pos__ = 1;
+        current_statement__ = 15;
+        if (lcm_sym2__) {
+          current_statement__ = 15;
+          if (lcm_sym1__) {
+            current_statement__ = 15;
+            assign(b_age_edu,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())),
+              rvalue(b_age_edu_flat__,
+                cons_list(index_uni(1), nil_index_list()),
+                "b_age_edu_flat__"), "assigning variable b_age_edu");
+            current_statement__ = 15;
+            pos__ = 2;
+            for (int sym2__ = 2; sym2__ <= n_age; ++sym2__) {
+              current_statement__ = 15;
+              assign(b_age_edu,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())),
+                b_age_edu_flat__[(pos__ - 1)], "assigning variable b_age_edu");
+              current_statement__ = 15;
+              pos__ = (pos__ + 1);}
+          } 
+          for (int sym1__ = 2; sym1__ <= n_edu; ++sym1__) {
+            current_statement__ = 15;
+            if (lcm_sym1__) {
+              current_statement__ = 15;
+              assign(b_age_edu,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                b_age_edu_flat__[(pos__ - 1)], "assigning variable b_age_edu");
+              current_statement__ = 15;
+              pos__ = (pos__ + 1);
+              for (int sym2__ = 2; sym2__ <= n_age; ++sym2__) {
+                current_statement__ = 15;
+                assign(b_age_edu,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  b_age_edu_flat__[(pos__ - 1)],
+                  "assigning variable b_age_edu");
+                current_statement__ = 15;
+                pos__ = (pos__ + 1);}
+            } }
+        } 
+      }
+      current_statement__ = 16;
+      validate_non_negative_index("b_hat", "n_state", n_state);
+      Eigen::Matrix<double, -1, 1> b_hat;
+      b_hat = Eigen::Matrix<double, -1, 1>(n_state);
+      stan::math::fill(b_hat, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> b_hat_flat__;
+        current_statement__ = 16;
+        assign(b_hat_flat__, nil_index_list(), context__.vals_r("b_hat"),
+          "assigning variable b_hat_flat__");
+        current_statement__ = 16;
+        pos__ = 1;
+        lcm_sym4__ = logical_gte(n_state, 1);
+        if (lcm_sym4__) {
+          current_statement__ = 16;
+          assign(b_hat, cons_list(index_uni(1), nil_index_list()),
+            rvalue(b_hat_flat__, cons_list(index_uni(1), nil_index_list()),
+              "b_hat_flat__"), "assigning variable b_hat");
+          current_statement__ = 16;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= n_state; ++sym1__) {
+            current_statement__ = 16;
+            assign(b_hat, cons_list(index_uni(sym1__), nil_index_list()),
+              b_hat_flat__[(pos__ - 1)], "assigning variable b_hat");
+            current_statement__ = 16;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      vars__.push_back(sigma);
+      vars__.push_back(sigma_age);
+      vars__.push_back(sigma_edu);
+      vars__.push_back(sigma_state);
+      vars__.push_back(sigma_region);
+      vars__.push_back(sigma_age_edu);
+      vars__.push_back(b_0);
+      vars__.push_back(b_female);
+      vars__.push_back(b_black);
+      vars__.push_back(b_female_black);
+      vars__.push_back(b_v_prev);
+      if (lcm_sym1__) {
+        vars__.push_back(
+          rvalue(b_age, cons_list(index_uni(1), nil_index_list()), "b_age"));
+        for (int sym1__ = 2; sym1__ <= n_age; ++sym1__) {
+          vars__.push_back(b_age[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym2__) {
+        vars__.push_back(
+          rvalue(b_edu, cons_list(index_uni(1), nil_index_list()), "b_edu"));
+        for (int sym1__ = 2; sym1__ <= n_edu; ++sym1__) {
+          vars__.push_back(b_edu[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym3__) {
+        vars__.push_back(
+          rvalue(b_region, cons_list(index_uni(1), nil_index_list()),
+            "b_region"));
+        for (int sym1__ = 2; sym1__ <= n_region; ++sym1__) {
+          vars__.push_back(b_region[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym2__) {
+        if (lcm_sym1__) {
+          vars__.push_back(
+            rvalue(b_age_edu,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "b_age_edu"));
+          for (int sym2__ = 2; sym2__ <= n_age; ++sym2__) {
+            vars__.push_back(
+              rvalue(b_age_edu,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "b_age_edu"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= n_edu; ++sym1__) {
+          if (lcm_sym1__) {
+            vars__.push_back(
+              rvalue(b_age_edu,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                "b_age_edu"));
+            for (int sym2__ = 2; sym2__ <= n_age; ++sym2__) {
+              vars__.push_back(
+                rvalue(b_age_edu,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  "b_age_edu"));}
+          } }
+      } 
+      if (lcm_sym4__) {
+        vars__.push_back(
+          rvalue(b_hat, cons_list(index_uni(1), nil_index_list()), "b_hat"));
+        for (int sym1__ = 2; sym1__ <= n_state; ++sym1__) {
+          vars__.push_back(b_hat[(sym1__ - 1)]);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("sigma");
+    names__.push_back("sigma_age");
+    names__.push_back("sigma_edu");
+    names__.push_back("sigma_state");
+    names__.push_back("sigma_region");
+    names__.push_back("sigma_age_edu");
+    names__.push_back("b_0");
+    names__.push_back("b_female");
+    names__.push_back("b_black");
+    names__.push_back("b_female_black");
+    names__.push_back("b_v_prev");
+    names__.push_back("b_age");
+    names__.push_back("b_edu");
+    names__.push_back("b_region");
+    names__.push_back("b_age_edu");
+    names__.push_back("b_hat");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_age);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_edu);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_region);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_age);
+    
+    dims__.push_back(n_edu);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_state);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "sigma");
+    param_names__.push_back(std::string() + "sigma_age");
+    param_names__.push_back(std::string() + "sigma_edu");
+    param_names__.push_back(std::string() + "sigma_state");
+    param_names__.push_back(std::string() + "sigma_region");
+    param_names__.push_back(std::string() + "sigma_age_edu");
+    param_names__.push_back(std::string() + "b_0");
+    param_names__.push_back(std::string() + "b_female");
+    param_names__.push_back(std::string() + "b_black");
+    param_names__.push_back(std::string() + "b_female_black");
+    param_names__.push_back(std::string() + "b_v_prev");
+    for (int sym87__ = 1; sym87__ <= n_age; ++sym87__) {
+      {
+        param_names__.push_back(std::string() + "b_age" + '.' + std::to_string(sym87__));
+      }}
+    for (int sym87__ = 1; sym87__ <= n_edu; ++sym87__) {
+      {
+        param_names__.push_back(std::string() + "b_edu" + '.' + std::to_string(sym87__));
+      }}
+    for (int sym87__ = 1; sym87__ <= n_region; ++sym87__) {
+      {
+        param_names__.push_back(std::string() + "b_region" + '.' + std::to_string(sym87__));
+      }}
+    for (int sym87__ = 1; sym87__ <= n_edu; ++sym87__) {
+      {
+        for (int sym88__ = 1; sym88__ <= n_age; ++sym88__) {
+          {
+            param_names__.push_back(std::string() + "b_age_edu" + '.' + std::to_string(sym88__) + '.' + std::to_string(sym87__));
+          }}
+      }}
+    for (int sym87__ = 1; sym87__ <= n_state; ++sym87__) {
+      {
+        param_names__.push_back(std::string() + "b_hat" + '.' + std::to_string(sym87__));
+      }}
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "sigma");
+    param_names__.push_back(std::string() + "sigma_age");
+    param_names__.push_back(std::string() + "sigma_edu");
+    param_names__.push_back(std::string() + "sigma_state");
+    param_names__.push_back(std::string() + "sigma_region");
+    param_names__.push_back(std::string() + "sigma_age_edu");
+    param_names__.push_back(std::string() + "b_0");
+    param_names__.push_back(std::string() + "b_female");
+    param_names__.push_back(std::string() + "b_black");
+    param_names__.push_back(std::string() + "b_female_black");
+    param_names__.push_back(std::string() + "b_v_prev");
+    for (int sym87__ = 1; sym87__ <= n_age; ++sym87__) {
+      {
+        param_names__.push_back(std::string() + "b_age" + '.' + std::to_string(sym87__));
+      }}
+    for (int sym87__ = 1; sym87__ <= n_edu; ++sym87__) {
+      {
+        param_names__.push_back(std::string() + "b_edu" + '.' + std::to_string(sym87__));
+      }}
+    for (int sym87__ = 1; sym87__ <= n_region; ++sym87__) {
+      {
+        param_names__.push_back(std::string() + "b_region" + '.' + std::to_string(sym87__));
+      }}
+    for (int sym87__ = 1; sym87__ <= n_edu; ++sym87__) {
+      {
+        for (int sym88__ = 1; sym88__ <= n_age; ++sym88__) {
+          {
+            param_names__.push_back(std::string() + "b_age_edu" + '.' + std::to_string(sym88__) + '.' + std::to_string(sym87__));
+          }}
+      }}
+    for (int sym87__ = 1; sym87__ <= n_state; ++sym87__) {
+      {
+        param_names__.push_back(std::string() + "b_hat" + '.' + std::to_string(sym87__));
+      }}
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_age\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_edu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_state\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_region\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_age_edu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_female\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_black\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_female_black\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_v_prev\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_age\",\"type\":{\"name\":\"vector\",\"length\":" << n_age << "},\"block\":\"parameters\"},{\"name\":\"b_edu\",\"type\":{\"name\":\"vector\",\"length\":" << n_edu << "},\"block\":\"parameters\"},{\"name\":\"b_region\",\"type\":{\"name\":\"vector\",\"length\":" << n_region << "},\"block\":\"parameters\"},{\"name\":\"b_age_edu\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_age << ",\"cols\":" << n_edu << "},\"block\":\"parameters\"},{\"name\":\"b_hat\",\"type\":{\"name\":\"vector\",\"length\":" << n_state << "},\"block\":\"parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_age\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_edu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_state\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_region\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_age_edu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_female\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_black\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_female_black\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_v_prev\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b_age\",\"type\":{\"name\":\"vector\",\"length\":" << n_age << "},\"block\":\"parameters\"},{\"name\":\"b_edu\",\"type\":{\"name\":\"vector\",\"length\":" << n_edu << "},\"block\":\"parameters\"},{\"name\":\"b_region\",\"type\":{\"name\":\"vector\",\"length\":" << n_region << "},\"block\":\"parameters\"},{\"name\":\"b_age_edu\",\"type\":{\"name\":\"matrix\",\"rows\":" << n_age << ",\"cols\":" << n_edu << "},\"block\":\"parameters\"},{\"name\":\"b_hat\",\"type\":{\"name\":\"vector\",\"length\":" << n_state << "},\"block\":\"parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef dce_fail_model_namespace::dce_fail_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-experiment.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace expr_prop_experiment_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'expr-prop-experiment.stan', line 2, column 2 to column 8)",
+                                                      " (in 'expr-prop-experiment.stan', line 5, column 2 to column 9)",
+                                                      " (in 'expr-prop-experiment.stan', line 6, column 2 to column 9)",
+                                                      " (in 'expr-prop-experiment.stan', line 7, column 2 to column 9)",
+                                                      " (in 'expr-prop-experiment.stan', line 8, column 2 to column 28)",
+                                                      " (in 'expr-prop-experiment.stan', line 10, column 2 to column 23)",
+                                                      " (in 'expr-prop-experiment.stan', line 11, column 2 to column 23)",
+                                                      " (in 'expr-prop-experiment.stan', line 12, column 2 to column 23)"};
+
+
+
+class expr_prop_experiment_model : public model_base_crtp<expr_prop_experiment_model> {
+
+ private:
+  double lcm_sym4__;
+  int pos__;
+  int j;
+  double z;
+  double x;
+  double y;
+  double i;
+ 
+ public:
+  ~expr_prop_experiment_model() { }
+  
+  std::string model_name() const { return "expr_prop_experiment_model"; }
+  
+  expr_prop_experiment_model(stan::io::var_context& context__,
+                             unsigned int random_seed__ = 0,
+                             std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "expr_prop_experiment_model_namespace::expr_prop_experiment_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","j","int",
+          context__.to_vec());
+      j = std::numeric_limits<int>::min();
+      
+      current_statement__ = 1;
+      j = context__.vals_i("j")[(1 - 1)];
+      z = std::numeric_limits<double>::quiet_NaN();
+      
+      x = std::numeric_limits<double>::quiet_NaN();
+      
+      y = std::numeric_limits<double>::quiet_NaN();
+      
+      i = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 5;
+      i = normal_rng(5, 1, base_rng__);
+      lcm_sym4__ = (i * j);
+      z = lcm_sym4__;
+      current_statement__ = 6;
+      x = normal_rng(lcm_sym4__, 1, base_rng__);
+      current_statement__ = 7;
+      i = normal_rng(5, 1, base_rng__);
+      current_statement__ = 8;
+      y = normal_rng(z, 1, base_rng__);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "expr_prop_experiment_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "expr_prop_experiment_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      int lcm_sym2__;
+      int lcm_sym1__;
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+
+typedef expr_prop_experiment_model_namespace::expr_prop_experiment_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-experiment2.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace expr_prop_experiment2_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'expr-prop-experiment2.stan', line 2, column 2 to column 8)",
+                                                      " (in 'expr-prop-experiment2.stan', line 5, column 2 to column 13)",
+                                                      " (in 'expr-prop-experiment2.stan', line 6, column 2 to column 9)",
+                                                      " (in 'expr-prop-experiment2.stan', line 8, column 4 to column 32)",
+                                                      " (in 'expr-prop-experiment2.stan', line 10, column 4 to column 25)",
+                                                      " (in 'expr-prop-experiment2.stan', line 7, column 2 to line 11, column 3)",
+                                                      " (in 'expr-prop-experiment2.stan', line 12, column 2 to column 23)"};
+
+
+
+class expr_prop_experiment2_model : public model_base_crtp<expr_prop_experiment2_model> {
+
+ private:
+  double lcm_sym4__;
+  int pos__;
+  int j;
+  double z;
+  double y;
+ 
+ public:
+  ~expr_prop_experiment2_model() { }
+  
+  std::string model_name() const { return "expr_prop_experiment2_model"; }
+  
+  expr_prop_experiment2_model(stan::io::var_context& context__,
+                              unsigned int random_seed__ = 0,
+                              std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "expr_prop_experiment2_model_namespace::expr_prop_experiment2_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","j","int",
+          context__.to_vec());
+      j = std::numeric_limits<int>::min();
+      
+      current_statement__ = 1;
+      j = context__.vals_i("j")[(1 - 1)];
+      z = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      z = 1;
+      y = std::numeric_limits<double>::quiet_NaN();
+      
+      {
+        double x;
+        x = std::numeric_limits<double>::quiet_NaN();
+        
+        current_statement__ = 4;
+        x = normal_rng(123, 1, base_rng__);
+        lcm_sym4__ = (x * 2);
+        z = lcm_sym4__;
+        current_statement__ = 5;
+        y = normal_rng(lcm_sym4__, 1, base_rng__);
+      }
+      current_statement__ = 7;
+      y = normal_rng(z, 1, base_rng__);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "expr_prop_experiment2_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "expr_prop_experiment2_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      int lcm_sym2__;
+      int lcm_sym1__;
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+
+typedef expr_prop_experiment2_model_namespace::expr_prop_experiment2_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace expr_prop_fail_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'expr-prop-fail.stan', line 7, column 2 to column 16)",
+                                                      " (in 'expr-prop-fail.stan', line 8, column 2 to column 25)",
+                                                      " (in 'expr-prop-fail.stan', line 9, column 2 to column 31)",
+                                                      " (in 'expr-prop-fail.stan', line 13, column 1 to column 22)",
+                                                      " (in 'expr-prop-fail.stan', line 14, column 1 to column 19)",
+                                                      " (in 'expr-prop-fail.stan', line 15, column 1 to column 20)",
+                                                      " (in 'expr-prop-fail.stan', line 17, column 3 to line 19, column 58)",
+                                                      " (in 'expr-prop-fail.stan', line 16, column 1 to line 19, column 58)",
+                                                      " (in 'expr-prop-fail.stan', line 2, column 1 to column 18)",
+                                                      " (in 'expr-prop-fail.stan', line 3, column 1 to column 13)"};
+
+
+
+class expr_prop_fail_model : public model_base_crtp<expr_prop_fail_model> {
+
+ private:
+  double lcm_sym31__;
+  double lcm_sym30__;
+  int lcm_sym29__;
+  int lcm_sym28__;
+  int pos__;
+  int N;
+  Eigen::Matrix<double, -1, 1> y;
+ 
+ public:
+  ~expr_prop_fail_model() { }
+  
+  std::string model_name() const { return "expr_prop_fail_model"; }
+  
+  expr_prop_fail_model(stan::io::var_context& context__,
+                       unsigned int random_seed__ = 0,
+                       std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "expr_prop_fail_model_namespace::expr_prop_fail_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","N","int",
+          context__.to_vec());
+      N = std::numeric_limits<int>::min();
+      
+      current_statement__ = 9;
+      N = context__.vals_i("N")[(1 - 1)];
+      current_statement__ = 10;
+      validate_non_negative_index("y", "N", N);
+      context__.validate_dims("data initialization","y","double",
+          context__.to_vec(N));
+      y = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(y, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> y_flat__;
+        current_statement__ = 10;
+        assign(y_flat__, nil_index_list(), context__.vals_r("y"),
+          "assigning variable y_flat__");
+        current_statement__ = 10;
+        pos__ = 1;
+        current_statement__ = 10;
+        if (logical_gte(N, 1)) {
+          current_statement__ = 10;
+          assign(y, cons_list(index_uni(1), nil_index_list()),
+            rvalue(y_flat__, cons_list(index_uni(1), nil_index_list()),
+              "y_flat__"), "assigning variable y");
+          current_statement__ = 10;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 10;
+            assign(y, cons_list(index_uni(sym1__), nil_index_list()),
+              y_flat__[(pos__ - 1)], "assigning variable y");
+            current_statement__ = 10;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 9;
+      current_statement__ = 9;
+      check_greater_or_equal(function__, "N", N, 0);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      current_statement__ = 1;
+      validate_non_negative_index("mu", "2", 2);
+      num_params_r__ += 2;
+      current_statement__ = 2;
+      validate_non_negative_index("sigma", "2", 2);
+      num_params_r__ += 2;
+      num_params_r__ += 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "expr_prop_fail_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      local_scalar_t__ lcm_sym27__;
+      double lcm_sym25__;
+      double lcm_sym23__;
+      double lcm_sym22__;
+      double lcm_sym21__;
+      double lcm_sym20__;
+      double lcm_sym19__;
+      int lcm_sym18__;
+      current_statement__ = 1;
+      validate_non_negative_index("mu", "2", 2);
+      Eigen::Matrix<local_scalar_t__, -1, 1> mu;
+      mu = Eigen::Matrix<local_scalar_t__, -1, 1>(2);
+      stan::math::fill(mu, DUMMY_VAR__);
+      
+      current_statement__ = 1;
+      mu = in__.vector(2);
+      current_statement__ = 1;
+      if (jacobian__) {
+        current_statement__ = 1;
+        assign(mu, nil_index_list(), stan::math::ordered_constrain(mu, lp__),
+          "assigning variable mu");
+      } else {
+        current_statement__ = 1;
+        assign(mu, nil_index_list(), stan::math::ordered_constrain(mu),
+          "assigning variable mu");
+      }
+      current_statement__ = 2;
+      validate_non_negative_index("sigma", "2", 2);
+      std::vector<local_scalar_t__> sigma;
+      sigma = std::vector<local_scalar_t__>(2, DUMMY_VAR__);
+      
+      {
+        current_statement__ = 2;
+        assign(sigma, cons_list(index_uni(1), nil_index_list()),
+          in__.scalar(), "assigning variable sigma");
+        {
+          current_statement__ = 2;
+          assign(sigma, cons_list(index_uni(2), nil_index_list()),
+            in__.scalar(), "assigning variable sigma");
+        }
+      }
+      {
+        current_statement__ = 2;
+        if (jacobian__) {
+          current_statement__ = 2;
+          assign(sigma, cons_list(index_uni(1), nil_index_list()),
+            stan::math::lb_constrain(
+              rvalue(sigma, cons_list(index_uni(1), nil_index_list()),
+                "sigma"), 0, lp__), "assigning variable sigma");
+        } else {
+          current_statement__ = 2;
+          assign(sigma, cons_list(index_uni(1), nil_index_list()),
+            stan::math::lb_constrain(
+              rvalue(sigma, cons_list(index_uni(1), nil_index_list()),
+                "sigma"), 0), "assigning variable sigma");
+        }
+        {
+          current_statement__ = 2;
+          if (jacobian__) {
+            current_statement__ = 2;
+            assign(sigma, cons_list(index_uni(2), nil_index_list()),
+              stan::math::lb_constrain(
+                rvalue(sigma, cons_list(index_uni(2), nil_index_list()),
+                  "sigma"), 0, lp__), "assigning variable sigma");
+          } else {
+            current_statement__ = 2;
+            assign(sigma, cons_list(index_uni(2), nil_index_list()),
+              stan::math::lb_constrain(
+                rvalue(sigma, cons_list(index_uni(2), nil_index_list()),
+                  "sigma"), 0), "assigning variable sigma");
+          }
+        }
+      }
+      local_scalar_t__ theta;
+      theta = DUMMY_VAR__;
+      
+      current_statement__ = 3;
+      theta = in__.scalar();
+      current_statement__ = 3;
+      if (jacobian__) {
+        current_statement__ = 3;
+        theta = stan::math::lub_constrain(theta, 0, 1, lp__);
+      } else {
+        current_statement__ = 3;
+        theta = stan::math::lub_constrain(theta, 0, 1);
+      }
+      {
+        current_statement__ = 4;
+        lp_accum__.add(normal_log<propto__>(sigma, 0, 2));
+        current_statement__ = 5;
+        lp_accum__.add(normal_log<propto__>(mu, 0, 2));
+        current_statement__ = 6;
+        lp_accum__.add(beta_log<propto__>(theta, 5, 5));
+        current_statement__ = 8;
+        if (logical_gte(N, 1)) {
+          lcm_sym27__ = rvalue(sigma,
+                          cons_list(index_uni(1), nil_index_list()), "sigma");
+          lp_accum__.add(
+            log_mix(theta,
+              normal_lpdf<false>(
+                rvalue(y, cons_list(index_uni(1), nil_index_list()), "y"),
+                rvalue(mu, cons_list(index_uni(1), nil_index_list()), "mu"),
+                lcm_sym27__),
+              normal_lpdf<false>(
+                rvalue(y, cons_list(index_uni(1), nil_index_list()), "y"),
+                rvalue(mu, cons_list(index_uni(2), nil_index_list()), "mu"),
+                rvalue(sigma, cons_list(index_uni(2), nil_index_list()),
+                  "sigma"))));
+          for (int n = 2; n <= N; ++n) {
+            current_statement__ = 7;
+            lp_accum__.add(
+              log_mix(theta,
+                normal_lpdf<false>(
+                  rvalue(y, cons_list(index_uni(n), nil_index_list()), "y"),
+                  rvalue(mu, cons_list(index_uni(1), nil_index_list()), "mu"),
+                  lcm_sym27__),
+                normal_lpdf<false>(
+                  rvalue(y, cons_list(index_uni(n), nil_index_list()), "y"),
+                  rvalue(mu, cons_list(index_uni(2), nil_index_list()), "mu"),
+                  rvalue(sigma, cons_list(index_uni(2), nil_index_list()),
+                    "sigma"))));}
+        } 
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "expr_prop_fail_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym17__;
+      double lcm_sym16__;
+      double lcm_sym15__;
+      double lcm_sym14__;
+      int lcm_sym11__;
+      int lcm_sym10__;
+      current_statement__ = 1;
+      validate_non_negative_index("mu", "2", 2);
+      Eigen::Matrix<double, -1, 1> mu;
+      mu = Eigen::Matrix<double, -1, 1>(2);
+      stan::math::fill(mu, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 1;
+      mu = in__.vector(2);
+      current_statement__ = 1;
+      assign(mu, nil_index_list(), stan::math::ordered_constrain(mu),
+        "assigning variable mu");
+      current_statement__ = 2;
+      validate_non_negative_index("sigma", "2", 2);
+      std::vector<double> sigma;
+      sigma = std::vector<double>(2, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        current_statement__ = 2;
+        assign(sigma, cons_list(index_uni(1), nil_index_list()),
+          in__.scalar(), "assigning variable sigma");
+        {
+          current_statement__ = 2;
+          assign(sigma, cons_list(index_uni(2), nil_index_list()),
+            in__.scalar(), "assigning variable sigma");
+        }
+      }
+      {
+        current_statement__ = 2;
+        assign(sigma, cons_list(index_uni(1), nil_index_list()),
+          stan::math::lb_constrain(
+            rvalue(sigma, cons_list(index_uni(1), nil_index_list()), "sigma"),
+            0), "assigning variable sigma");
+        {
+          current_statement__ = 2;
+          assign(sigma, cons_list(index_uni(2), nil_index_list()),
+            stan::math::lb_constrain(
+              rvalue(sigma, cons_list(index_uni(2), nil_index_list()),
+                "sigma"), 0), "assigning variable sigma");
+        }
+      }
+      double theta;
+      theta = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      theta = in__.scalar();
+      current_statement__ = 3;
+      theta = stan::math::lub_constrain(theta, 0, 1);
+      {
+        vars__.push_back(
+          rvalue(mu, cons_list(index_uni(1), nil_index_list()), "mu"));
+        {
+          vars__.push_back(
+            rvalue(mu, cons_list(index_uni(2), nil_index_list()), "mu"));
+        }
+      }
+      {
+        vars__.push_back(
+          rvalue(sigma, cons_list(index_uni(1), nil_index_list()), "sigma"));
+        {
+          vars__.push_back(
+            rvalue(sigma, cons_list(index_uni(2), nil_index_list()), "sigma"));
+        }
+      }
+      vars__.push_back(theta);
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym9__;
+      double lcm_sym8__;
+      double lcm_sym7__;
+      double lcm_sym6__;
+      double lcm_sym5__;
+      double lcm_sym4__;
+      int lcm_sym1__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      current_statement__ = 1;
+      validate_non_negative_index("mu", "2", 2);
+      Eigen::Matrix<double, -1, 1> mu;
+      mu = Eigen::Matrix<double, -1, 1>(2);
+      stan::math::fill(mu, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> mu_flat__;
+        current_statement__ = 1;
+        assign(mu_flat__, nil_index_list(), context__.vals_r("mu"),
+          "assigning variable mu_flat__");
+        current_statement__ = 1;
+        pos__ = 1;
+        {
+          current_statement__ = 1;
+          assign(mu, cons_list(index_uni(1), nil_index_list()),
+            rvalue(mu_flat__, cons_list(index_uni(1), nil_index_list()),
+              "mu_flat__"), "assigning variable mu");
+          current_statement__ = 1;
+          pos__ = 2;
+          {
+            current_statement__ = 1;
+            assign(mu, cons_list(index_uni(2), nil_index_list()),
+              mu_flat__[(pos__ - 1)], "assigning variable mu");
+            current_statement__ = 1;
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      current_statement__ = 1;
+      assign(mu, nil_index_list(), stan::math::ordered_free(mu),
+        "assigning variable mu");
+      current_statement__ = 2;
+      validate_non_negative_index("sigma", "2", 2);
+      std::vector<double> sigma;
+      sigma = std::vector<double>(2, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 2;
+      assign(sigma, nil_index_list(), context__.vals_r("sigma"),
+        "assigning variable sigma");
+      {
+        current_statement__ = 2;
+        assign(sigma, cons_list(index_uni(1), nil_index_list()),
+          stan::math::lb_free(
+            rvalue(sigma, cons_list(index_uni(1), nil_index_list()), "sigma"),
+            0), "assigning variable sigma");
+        {
+          current_statement__ = 2;
+          assign(sigma, cons_list(index_uni(2), nil_index_list()),
+            stan::math::lb_free(
+              rvalue(sigma, cons_list(index_uni(2), nil_index_list()),
+                "sigma"), 0), "assigning variable sigma");
+        }
+      }
+      double theta;
+      theta = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      theta = context__.vals_r("theta")[(1 - 1)];
+      current_statement__ = 3;
+      theta = stan::math::lub_free(theta, 0, 1);
+      {
+        vars__.push_back(
+          rvalue(mu, cons_list(index_uni(1), nil_index_list()), "mu"));
+        {
+          vars__.push_back(
+            rvalue(mu, cons_list(index_uni(2), nil_index_list()), "mu"));
+        }
+      }
+      {
+        vars__.push_back(
+          rvalue(sigma, cons_list(index_uni(1), nil_index_list()), "sigma"));
+        {
+          vars__.push_back(
+            rvalue(sigma, cons_list(index_uni(2), nil_index_list()), "sigma"));
+        }
+      }
+      vars__.push_back(theta);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("mu");
+    names__.push_back("sigma");
+    names__.push_back("theta");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dims__.push_back(2);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(2);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    for (int sym32__ = 1; sym32__ <= 2; ++sym32__) {
+      {
+        param_names__.push_back(std::string() + "mu" + '.' + std::to_string(sym32__));
+      }}
+    for (int sym32__ = 1; sym32__ <= 2; ++sym32__) {
+      {
+        param_names__.push_back(std::string() + "sigma" + '.' + std::to_string(sym32__));
+      }}
+    param_names__.push_back(std::string() + "theta");
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    for (int sym32__ = 1; sym32__ <= 2; ++sym32__) {
+      {
+        param_names__.push_back(std::string() + "mu" + '.' + std::to_string(sym32__));
+      }}
+    for (int sym32__ = 1; sym32__ <= 2; ++sym32__) {
+      {
+        param_names__.push_back(std::string() + "sigma" + '.' + std::to_string(sym32__));
+      }}
+    param_names__.push_back(std::string() + "theta");
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mu\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"array\",\"length\":" << 2 << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mu\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"array\",\"length\":" << 2 << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef expr_prop_fail_model_namespace::expr_prop_fail_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail2.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace expr_prop_fail2_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'expr-prop-fail2.stan', line 7, column 2 to column 10)",
+                                                      " (in 'expr-prop-fail2.stan', line 8, column 2 to column 16)",
+                                                      " (in 'expr-prop-fail2.stan', line 9, column 2 to column 20)",
+                                                      " (in 'expr-prop-fail2.stan', line 12, column 2 to column 26)",
+                                                      " (in 'expr-prop-fail2.stan', line 13, column 2 to column 26)",
+                                                      " (in 'expr-prop-fail2.stan', line 2, column 2 to column 17)",
+                                                      " (in 'expr-prop-fail2.stan', line 3, column 2 to column 12)",
+                                                      " (in 'expr-prop-fail2.stan', line 4, column 2 to column 25)"};
+
+
+
+class expr_prop_fail2_model : public model_base_crtp<expr_prop_fail2_model> {
+
+ private:
+  double lcm_sym14__;
+  double lcm_sym13__;
+  int lcm_sym12__;
+  int pos__;
+  int J;
+  std::vector<double> y;
+  std::vector<double> sigma;
+ 
+ public:
+  ~expr_prop_fail2_model() { }
+  
+  std::string model_name() const { return "expr_prop_fail2_model"; }
+  
+  expr_prop_fail2_model(stan::io::var_context& context__,
+                        unsigned int random_seed__ = 0,
+                        std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "expr_prop_fail2_model_namespace::expr_prop_fail2_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","J","int",
+          context__.to_vec());
+      J = std::numeric_limits<int>::min();
+      
+      current_statement__ = 6;
+      J = context__.vals_i("J")[(1 - 1)];
+      current_statement__ = 7;
+      validate_non_negative_index("y", "J", J);
+      context__.validate_dims("data initialization","y","double",
+          context__.to_vec(J));
+      y = std::vector<double>(J, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 7;
+      assign(y, nil_index_list(), context__.vals_r("y"),
+        "assigning variable y");
+      current_statement__ = 8;
+      validate_non_negative_index("sigma", "J", J);
+      context__.validate_dims("data initialization","sigma","double",
+          context__.to_vec(J));
+      sigma = std::vector<double>(J, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 8;
+      assign(sigma, nil_index_list(), context__.vals_r("sigma"),
+        "assigning variable sigma");
+      current_statement__ = 6;
+      current_statement__ = 6;
+      check_greater_or_equal(function__, "J", J, 0);
+      current_statement__ = 8;
+      if (logical_gte(J, 1)) {
+        current_statement__ = 8;
+        current_statement__ = 8;
+        check_greater_or_equal(function__, "sigma[sym1__]",
+                               rvalue(sigma,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "sigma"), 0);
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          current_statement__ = 8;
+          current_statement__ = 8;
+          check_greater_or_equal(function__, "sigma[sym1__]",
+                                 sigma[(sym1__ - 1)], 0);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      current_statement__ = 2;
+      validate_non_negative_index("theta", "J", J);
+      num_params_r__ += J;
+      num_params_r__ += 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "expr_prop_fail2_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym11__;
+      double lcm_sym10__;
+      int lcm_sym9__;
+      local_scalar_t__ mu;
+      mu = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      mu = in__.scalar();
+      current_statement__ = 2;
+      validate_non_negative_index("theta", "J", J);
+      std::vector<local_scalar_t__> theta;
+      theta = std::vector<local_scalar_t__>(J, DUMMY_VAR__);
+      
+      current_statement__ = 2;
+      if (logical_gte(J, 1)) {
+        current_statement__ = 2;
+        assign(theta, cons_list(index_uni(1), nil_index_list()),
+          in__.scalar(), "assigning variable theta");
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          current_statement__ = 2;
+          assign(theta, cons_list(index_uni(sym1__), nil_index_list()),
+            in__.scalar(), "assigning variable theta");}
+      } 
+      local_scalar_t__ tau;
+      tau = DUMMY_VAR__;
+      
+      current_statement__ = 3;
+      tau = in__.scalar();
+      current_statement__ = 3;
+      if (jacobian__) {
+        current_statement__ = 3;
+        tau = stan::math::lb_constrain(tau, 0, lp__);
+      } else {
+        current_statement__ = 3;
+        tau = stan::math::lb_constrain(tau, 0);
+      }
+      {
+        current_statement__ = 4;
+        lp_accum__.add(normal_log<propto__>(theta, mu, tau));
+        current_statement__ = 5;
+        lp_accum__.add(normal_log<propto__>(y, theta, sigma));
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "expr_prop_fail2_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym8__;
+      double lcm_sym7__;
+      int lcm_sym6__;
+      int lcm_sym5__;
+      int lcm_sym4__;
+      double mu;
+      mu = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mu = in__.scalar();
+      current_statement__ = 2;
+      validate_non_negative_index("theta", "J", J);
+      std::vector<double> theta;
+      theta = std::vector<double>(J, std::numeric_limits<double>::quiet_NaN());
+      
+      lcm_sym4__ = logical_gte(J, 1);
+      if (lcm_sym4__) {
+        current_statement__ = 2;
+        assign(theta, cons_list(index_uni(1), nil_index_list()),
+          in__.scalar(), "assigning variable theta");
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          current_statement__ = 2;
+          assign(theta, cons_list(index_uni(sym1__), nil_index_list()),
+            in__.scalar(), "assigning variable theta");}
+      } 
+      double tau;
+      tau = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      tau = in__.scalar();
+      current_statement__ = 3;
+      tau = stan::math::lb_constrain(tau, 0);
+      vars__.push_back(mu);
+      if (lcm_sym4__) {
+        vars__.push_back(
+          rvalue(theta, cons_list(index_uni(1), nil_index_list()), "theta"));
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          vars__.push_back(theta[(sym1__ - 1)]);}
+      } 
+      vars__.push_back(tau);
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym3__;
+      double lcm_sym2__;
+      int lcm_sym1__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double mu;
+      mu = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mu = context__.vals_r("mu")[(1 - 1)];
+      current_statement__ = 2;
+      validate_non_negative_index("theta", "J", J);
+      std::vector<double> theta;
+      theta = std::vector<double>(J, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 2;
+      assign(theta, nil_index_list(), context__.vals_r("theta"),
+        "assigning variable theta");
+      double tau;
+      tau = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      tau = context__.vals_r("tau")[(1 - 1)];
+      current_statement__ = 3;
+      tau = stan::math::lb_free(tau, 0);
+      vars__.push_back(mu);
+      if (logical_gte(J, 1)) {
+        vars__.push_back(
+          rvalue(theta, cons_list(index_uni(1), nil_index_list()), "theta"));
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          vars__.push_back(theta[(sym1__ - 1)]);}
+      } 
+      vars__.push_back(tau);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("mu");
+    names__.push_back("theta");
+    names__.push_back("tau");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(J);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mu");
+    for (int sym15__ = 1; sym15__ <= J; ++sym15__) {
+      {
+        param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym15__));
+      }}
+    param_names__.push_back(std::string() + "tau");
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mu");
+    for (int sym15__ = 1; sym15__ <= J; ++sym15__) {
+      {
+        param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym15__));
+      }}
+    param_names__.push_back(std::string() + "tau");
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << J << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"tau\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mu\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << J << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"},{\"name\":\"tau\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef expr_prop_fail2_model_namespace::expr_prop_fail2_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail3.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace expr_prop_fail3_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'expr-prop-fail3.stan', line 19, column 2 to column 18)",
+                                                      " (in 'expr-prop-fail3.stan', line 20, column 2 to column 18)",
+                                                      " (in 'expr-prop-fail3.stan', line 21, column 2 to column 22)",
+                                                      " (in 'expr-prop-fail3.stan', line 22, column 2 to column 20)",
+                                                      " (in 'expr-prop-fail3.stan', line 23, column 2 to column 26)",
+                                                      " (in 'expr-prop-fail3.stan', line 24, column 2 to column 17)",
+                                                      " (in 'expr-prop-fail3.stan', line 25, column 2 to column 34)",
+                                                      " (in 'expr-prop-fail3.stan', line 26, column 2 to column 34)",
+                                                      " (in 'expr-prop-fail3.stan', line 27, column 2 to column 34)",
+                                                      " (in 'expr-prop-fail3.stan', line 28, column 2 to column 34)",
+                                                      " (in 'expr-prop-fail3.stan', line 29, column 2 to column 34)",
+                                                      " (in 'expr-prop-fail3.stan', line 32, column 2 to column 18)",
+                                                      " (in 'expr-prop-fail3.stan', line 35, column 4 to line 38, column 66)",
+                                                      " (in 'expr-prop-fail3.stan', line 34, column 2 to line 38, column 66)",
+                                                      " (in 'expr-prop-fail3.stan', line 41, column 2 to column 26)",
+                                                      " (in 'expr-prop-fail3.stan', line 42, column 2 to column 26)",
+                                                      " (in 'expr-prop-fail3.stan', line 43, column 2 to column 26)",
+                                                      " (in 'expr-prop-fail3.stan', line 44, column 2 to column 26)",
+                                                      " (in 'expr-prop-fail3.stan', line 45, column 2 to column 26)",
+                                                      " (in 'expr-prop-fail3.stan', line 46, column 2 to column 24)",
+                                                      " (in 'expr-prop-fail3.stan', line 47, column 2 to column 29)",
+                                                      " (in 'expr-prop-fail3.stan', line 2, column 2 to column 17)",
+                                                      " (in 'expr-prop-fail3.stan', line 3, column 2 to column 21)",
+                                                      " (in 'expr-prop-fail3.stan', line 4, column 2 to column 25)",
+                                                      " (in 'expr-prop-fail3.stan', line 5, column 2 to column 21)",
+                                                      " (in 'expr-prop-fail3.stan', line 6, column 2 to column 29)",
+                                                      " (in 'expr-prop-fail3.stan', line 7, column 2 to column 23)",
+                                                      " (in 'expr-prop-fail3.stan', line 8, column 2 to column 34)",
+                                                      " (in 'expr-prop-fail3.stan', line 9, column 2 to column 42)",
+                                                      " (in 'expr-prop-fail3.stan', line 10, column 2 to column 35)",
+                                                      " (in 'expr-prop-fail3.stan', line 11, column 2 to column 34)",
+                                                      " (in 'expr-prop-fail3.stan', line 12, column 2 to column 36)",
+                                                      " (in 'expr-prop-fail3.stan', line 13, column 2 to column 50)",
+                                                      " (in 'expr-prop-fail3.stan', line 14, column 2 to column 38)",
+                                                      " (in 'expr-prop-fail3.stan', line 15, column 2 to column 24)",
+                                                      " (in 'expr-prop-fail3.stan', line 16, column 2 to column 28)"};
+
+
+
+class expr_prop_fail3_model : public model_base_crtp<expr_prop_fail3_model> {
+
+ private:
+  int lcm_sym84__;
+  int lcm_sym83__;
+  double lcm_sym82__;
+  double lcm_sym81__;
+  int lcm_sym80__;
+  int lcm_sym79__;
+  int lcm_sym78__;
+  int lcm_sym77__;
+  double lcm_sym76__;
+  double lcm_sym75__;
+  int lcm_sym74__;
+  int lcm_sym73__;
+  double lcm_sym72__;
+  double lcm_sym71__;
+  int lcm_sym70__;
+  int lcm_sym69__;
+  int lcm_sym68__;
+  int lcm_sym67__;
+  int lcm_sym66__;
+  int lcm_sym65__;
+  int pos__;
+  int N;
+  int n_age;
+  int n_age_edu;
+  int n_edu;
+  int n_region_full;
+  int n_state;
+  std::vector<int> age;
+  std::vector<int> age_edu;
+  Eigen::Matrix<double, -1, 1> black;
+  std::vector<int> edu;
+  Eigen::Matrix<double, -1, 1> female;
+  std::vector<int> region_full;
+  std::vector<int> state;
+  Eigen::Matrix<double, -1, 1> v_prev_full;
+  std::vector<int> y;
+ 
+ public:
+  ~expr_prop_fail3_model() { }
+  
+  std::string model_name() const { return "expr_prop_fail3_model"; }
+  
+  expr_prop_fail3_model(stan::io::var_context& context__,
+                        unsigned int random_seed__ = 0,
+                        std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "expr_prop_fail3_model_namespace::expr_prop_fail3_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","N","int",
+          context__.to_vec());
+      N = std::numeric_limits<int>::min();
+      
+      current_statement__ = 22;
+      N = context__.vals_i("N")[(1 - 1)];
+      context__.validate_dims("data initialization","n_age","int",
+          context__.to_vec());
+      n_age = std::numeric_limits<int>::min();
+      
+      current_statement__ = 23;
+      n_age = context__.vals_i("n_age")[(1 - 1)];
+      context__.validate_dims("data initialization","n_age_edu","int",
+          context__.to_vec());
+      n_age_edu = std::numeric_limits<int>::min();
+      
+      current_statement__ = 24;
+      n_age_edu = context__.vals_i("n_age_edu")[(1 - 1)];
+      context__.validate_dims("data initialization","n_edu","int",
+          context__.to_vec());
+      n_edu = std::numeric_limits<int>::min();
+      
+      current_statement__ = 25;
+      n_edu = context__.vals_i("n_edu")[(1 - 1)];
+      context__.validate_dims("data initialization","n_region_full","int",
+          context__.to_vec());
+      n_region_full = std::numeric_limits<int>::min();
+      
+      current_statement__ = 26;
+      n_region_full = context__.vals_i("n_region_full")[(1 - 1)];
+      context__.validate_dims("data initialization","n_state","int",
+          context__.to_vec());
+      n_state = std::numeric_limits<int>::min();
+      
+      current_statement__ = 27;
+      n_state = context__.vals_i("n_state")[(1 - 1)];
+      current_statement__ = 28;
+      validate_non_negative_index("age", "N", N);
+      context__.validate_dims("data initialization","age","int",
+          context__.to_vec(N));
+      age = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 28;
+      assign(age, nil_index_list(), context__.vals_i("age"),
+        "assigning variable age");
+      current_statement__ = 29;
+      validate_non_negative_index("age_edu", "N", N);
+      context__.validate_dims("data initialization","age_edu","int",
+          context__.to_vec(N));
+      age_edu = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 29;
+      assign(age_edu, nil_index_list(), context__.vals_i("age_edu"),
+        "assigning variable age_edu");
+      current_statement__ = 30;
+      validate_non_negative_index("black", "N", N);
+      context__.validate_dims("data initialization","black","double",
+          context__.to_vec(N));
+      black = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(black, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> black_flat__;
+        current_statement__ = 30;
+        assign(black_flat__, nil_index_list(), context__.vals_r("black"),
+          "assigning variable black_flat__");
+        current_statement__ = 30;
+        pos__ = 1;
+        lcm_sym65__ = logical_gte(N, 1);
+        if (lcm_sym65__) {
+          current_statement__ = 30;
+          assign(black, cons_list(index_uni(1), nil_index_list()),
+            rvalue(black_flat__, cons_list(index_uni(1), nil_index_list()),
+              "black_flat__"), "assigning variable black");
+          current_statement__ = 30;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 30;
+            assign(black, cons_list(index_uni(sym1__), nil_index_list()),
+              black_flat__[(pos__ - 1)], "assigning variable black");
+            current_statement__ = 30;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 31;
+      validate_non_negative_index("edu", "N", N);
+      context__.validate_dims("data initialization","edu","int",
+          context__.to_vec(N));
+      edu = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 31;
+      assign(edu, nil_index_list(), context__.vals_i("edu"),
+        "assigning variable edu");
+      current_statement__ = 32;
+      validate_non_negative_index("female", "N", N);
+      context__.validate_dims("data initialization","female","double",
+          context__.to_vec(N));
+      female = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(female, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> female_flat__;
+        current_statement__ = 32;
+        assign(female_flat__, nil_index_list(), context__.vals_r("female"),
+          "assigning variable female_flat__");
+        current_statement__ = 32;
+        pos__ = 1;
+        current_statement__ = 32;
+        if (lcm_sym65__) {
+          current_statement__ = 32;
+          assign(female, cons_list(index_uni(1), nil_index_list()),
+            rvalue(female_flat__, cons_list(index_uni(1), nil_index_list()),
+              "female_flat__"), "assigning variable female");
+          current_statement__ = 32;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 32;
+            assign(female, cons_list(index_uni(sym1__), nil_index_list()),
+              female_flat__[(pos__ - 1)], "assigning variable female");
+            current_statement__ = 32;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 33;
+      validate_non_negative_index("region_full", "N", N);
+      context__.validate_dims("data initialization","region_full","int",
+          context__.to_vec(N));
+      region_full = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 33;
+      assign(region_full, nil_index_list(), context__.vals_i("region_full"),
+        "assigning variable region_full");
+      current_statement__ = 34;
+      validate_non_negative_index("state", "N", N);
+      context__.validate_dims("data initialization","state","int",
+          context__.to_vec(N));
+      state = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 34;
+      assign(state, nil_index_list(), context__.vals_i("state"),
+        "assigning variable state");
+      current_statement__ = 35;
+      validate_non_negative_index("v_prev_full", "N", N);
+      context__.validate_dims("data initialization","v_prev_full","double",
+          context__.to_vec(N));
+      v_prev_full = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(v_prev_full, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> v_prev_full_flat__;
+        current_statement__ = 35;
+        assign(v_prev_full_flat__, nil_index_list(),
+          context__.vals_r("v_prev_full"),
+          "assigning variable v_prev_full_flat__");
+        current_statement__ = 35;
+        pos__ = 1;
+        current_statement__ = 35;
+        if (lcm_sym65__) {
+          current_statement__ = 35;
+          assign(v_prev_full, cons_list(index_uni(1), nil_index_list()),
+            rvalue(v_prev_full_flat__,
+              cons_list(index_uni(1), nil_index_list()),
+              "v_prev_full_flat__"), "assigning variable v_prev_full");
+          current_statement__ = 35;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 35;
+            assign(v_prev_full,
+              cons_list(index_uni(sym1__), nil_index_list()),
+              v_prev_full_flat__[(pos__ - 1)],
+              "assigning variable v_prev_full");
+            current_statement__ = 35;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 36;
+      validate_non_negative_index("y", "N", N);
+      context__.validate_dims("data initialization","y","int",
+          context__.to_vec(N));
+      y = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 36;
+      assign(y, nil_index_list(), context__.vals_i("y"),
+        "assigning variable y");
+      current_statement__ = 22;
+      current_statement__ = 22;
+      check_greater_or_equal(function__, "N", N, 0);
+      current_statement__ = 23;
+      current_statement__ = 23;
+      check_greater_or_equal(function__, "n_age", n_age, 0);
+      current_statement__ = 24;
+      current_statement__ = 24;
+      check_greater_or_equal(function__, "n_age_edu", n_age_edu, 0);
+      current_statement__ = 25;
+      current_statement__ = 25;
+      check_greater_or_equal(function__, "n_edu", n_edu, 0);
+      current_statement__ = 26;
+      current_statement__ = 26;
+      check_greater_or_equal(function__, "n_region_full", n_region_full, 0);
+      current_statement__ = 27;
+      current_statement__ = 27;
+      check_greater_or_equal(function__, "n_state", n_state, 0);
+      current_statement__ = 28;
+      if (lcm_sym65__) {
+        current_statement__ = 28;
+        current_statement__ = 28;
+        check_greater_or_equal(function__, "age[sym1__]",
+                               rvalue(age,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "age"), 0);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 28;
+          current_statement__ = 28;
+          check_greater_or_equal(function__, "age[sym1__]",
+                                 age[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 28;
+      if (lcm_sym65__) {
+        current_statement__ = 28;
+        current_statement__ = 28;
+        check_less_or_equal(function__, "age[sym1__]",
+                            rvalue(age,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "age"), n_age);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 28;
+          current_statement__ = 28;
+          check_less_or_equal(function__, "age[sym1__]", age[(sym1__ - 1)],
+                              n_age);}
+      } 
+      current_statement__ = 29;
+      if (lcm_sym65__) {
+        current_statement__ = 29;
+        current_statement__ = 29;
+        check_greater_or_equal(function__, "age_edu[sym1__]",
+                               rvalue(age_edu,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "age_edu"), 0);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 29;
+          current_statement__ = 29;
+          check_greater_or_equal(function__, "age_edu[sym1__]",
+                                 age_edu[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 29;
+      if (lcm_sym65__) {
+        current_statement__ = 29;
+        current_statement__ = 29;
+        check_less_or_equal(function__, "age_edu[sym1__]",
+                            rvalue(age_edu,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "age_edu"), n_age_edu);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 29;
+          current_statement__ = 29;
+          check_less_or_equal(function__, "age_edu[sym1__]",
+                              age_edu[(sym1__ - 1)], n_age_edu);}
+      } 
+      current_statement__ = 30;
+      current_statement__ = 30;
+      check_greater_or_equal(function__, "black", black, 0);
+      current_statement__ = 30;
+      current_statement__ = 30;
+      check_less_or_equal(function__, "black", black, 1);
+      current_statement__ = 31;
+      if (lcm_sym65__) {
+        current_statement__ = 31;
+        current_statement__ = 31;
+        check_greater_or_equal(function__, "edu[sym1__]",
+                               rvalue(edu,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "edu"), 0);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 31;
+          current_statement__ = 31;
+          check_greater_or_equal(function__, "edu[sym1__]",
+                                 edu[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 31;
+      if (lcm_sym65__) {
+        current_statement__ = 31;
+        current_statement__ = 31;
+        check_less_or_equal(function__, "edu[sym1__]",
+                            rvalue(edu,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "edu"), n_edu);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 31;
+          current_statement__ = 31;
+          check_less_or_equal(function__, "edu[sym1__]", edu[(sym1__ - 1)],
+                              n_edu);}
+      } 
+      current_statement__ = 32;
+      current_statement__ = 32;
+      check_greater_or_equal(function__, "female", female, 0);
+      current_statement__ = 32;
+      current_statement__ = 32;
+      check_less_or_equal(function__, "female", female, 1);
+      current_statement__ = 33;
+      if (lcm_sym65__) {
+        current_statement__ = 33;
+        current_statement__ = 33;
+        check_greater_or_equal(function__, "region_full[sym1__]",
+                               rvalue(region_full,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "region_full"), 0);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 33;
+          current_statement__ = 33;
+          check_greater_or_equal(function__, "region_full[sym1__]",
+                                 region_full[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 33;
+      if (lcm_sym65__) {
+        current_statement__ = 33;
+        current_statement__ = 33;
+        check_less_or_equal(function__, "region_full[sym1__]",
+                            rvalue(region_full,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "region_full"), n_region_full);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 33;
+          current_statement__ = 33;
+          check_less_or_equal(function__, "region_full[sym1__]",
+                              region_full[(sym1__ - 1)], n_region_full);}
+      } 
+      current_statement__ = 34;
+      if (lcm_sym65__) {
+        current_statement__ = 34;
+        current_statement__ = 34;
+        check_greater_or_equal(function__, "state[sym1__]",
+                               rvalue(state,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "state"), 0);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 34;
+          current_statement__ = 34;
+          check_greater_or_equal(function__, "state[sym1__]",
+                                 state[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 34;
+      if (lcm_sym65__) {
+        current_statement__ = 34;
+        current_statement__ = 34;
+        check_less_or_equal(function__, "state[sym1__]",
+                            rvalue(state,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "state"), n_state);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 34;
+          current_statement__ = 34;
+          check_less_or_equal(function__, "state[sym1__]",
+                              state[(sym1__ - 1)], n_state);}
+      } 
+      current_statement__ = 36;
+      if (lcm_sym65__) {
+        current_statement__ = 36;
+        current_statement__ = 36;
+        check_greater_or_equal(function__, "y[sym1__]",
+                               rvalue(y,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "y"), 0);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 36;
+          current_statement__ = 36;
+          check_greater_or_equal(function__, "y[sym1__]", y[(sym1__ - 1)], 0);
+        }
+      } 
+      current_statement__ = 36;
+      if (lcm_sym65__) {
+        current_statement__ = 36;
+        current_statement__ = 36;
+        check_less_or_equal(function__, "y[sym1__]",
+                            rvalue(y,
+                              cons_list(index_uni(1), nil_index_list()), "y"),
+                            1);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 36;
+          current_statement__ = 36;
+          check_less_or_equal(function__, "y[sym1__]", y[(sym1__ - 1)], 1);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      current_statement__ = 1;
+      validate_non_negative_index("a", "n_age", n_age);
+      num_params_r__ += n_age;
+      current_statement__ = 2;
+      validate_non_negative_index("b", "n_edu", n_edu);
+      num_params_r__ += n_edu;
+      current_statement__ = 3;
+      validate_non_negative_index("c", "n_age_edu", n_age_edu);
+      num_params_r__ += n_age_edu;
+      current_statement__ = 4;
+      validate_non_negative_index("d", "n_state", n_state);
+      num_params_r__ += n_state;
+      current_statement__ = 5;
+      validate_non_negative_index("e", "n_region_full", n_region_full);
+      num_params_r__ += n_region_full;
+      current_statement__ = 6;
+      validate_non_negative_index("beta", "5", 5);
+      num_params_r__ += 5;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "expr_prop_fail3_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym64__;
+      double lcm_sym63__;
+      double lcm_sym62__;
+      double lcm_sym61__;
+      double lcm_sym60__;
+      double lcm_sym59__;
+      double lcm_sym58__;
+      double lcm_sym57__;
+      double lcm_sym56__;
+      int lcm_sym55__;
+      current_statement__ = 1;
+      validate_non_negative_index("a", "n_age", n_age);
+      Eigen::Matrix<local_scalar_t__, -1, 1> a;
+      a = Eigen::Matrix<local_scalar_t__, -1, 1>(n_age);
+      stan::math::fill(a, DUMMY_VAR__);
+      
+      current_statement__ = 1;
+      a = in__.vector(n_age);
+      current_statement__ = 2;
+      validate_non_negative_index("b", "n_edu", n_edu);
+      Eigen::Matrix<local_scalar_t__, -1, 1> b;
+      b = Eigen::Matrix<local_scalar_t__, -1, 1>(n_edu);
+      stan::math::fill(b, DUMMY_VAR__);
+      
+      current_statement__ = 2;
+      b = in__.vector(n_edu);
+      current_statement__ = 3;
+      validate_non_negative_index("c", "n_age_edu", n_age_edu);
+      Eigen::Matrix<local_scalar_t__, -1, 1> c;
+      c = Eigen::Matrix<local_scalar_t__, -1, 1>(n_age_edu);
+      stan::math::fill(c, DUMMY_VAR__);
+      
+      current_statement__ = 3;
+      c = in__.vector(n_age_edu);
+      current_statement__ = 4;
+      validate_non_negative_index("d", "n_state", n_state);
+      Eigen::Matrix<local_scalar_t__, -1, 1> d;
+      d = Eigen::Matrix<local_scalar_t__, -1, 1>(n_state);
+      stan::math::fill(d, DUMMY_VAR__);
+      
+      current_statement__ = 4;
+      d = in__.vector(n_state);
+      current_statement__ = 5;
+      validate_non_negative_index("e", "n_region_full", n_region_full);
+      Eigen::Matrix<local_scalar_t__, -1, 1> e;
+      e = Eigen::Matrix<local_scalar_t__, -1, 1>(n_region_full);
+      stan::math::fill(e, DUMMY_VAR__);
+      
+      current_statement__ = 5;
+      e = in__.vector(n_region_full);
+      current_statement__ = 6;
+      validate_non_negative_index("beta", "5", 5);
+      Eigen::Matrix<local_scalar_t__, -1, 1> beta;
+      beta = Eigen::Matrix<local_scalar_t__, -1, 1>(5);
+      stan::math::fill(beta, DUMMY_VAR__);
+      
+      current_statement__ = 6;
+      beta = in__.vector(5);
+      local_scalar_t__ sigma_a;
+      sigma_a = DUMMY_VAR__;
+      
+      current_statement__ = 7;
+      sigma_a = in__.scalar();
+      current_statement__ = 7;
+      if (jacobian__) {
+        current_statement__ = 7;
+        sigma_a = stan::math::lub_constrain(sigma_a, 0, 100, lp__);
+      } else {
+        current_statement__ = 7;
+        sigma_a = stan::math::lub_constrain(sigma_a, 0, 100);
+      }
+      local_scalar_t__ sigma_b;
+      sigma_b = DUMMY_VAR__;
+      
+      current_statement__ = 8;
+      sigma_b = in__.scalar();
+      current_statement__ = 8;
+      if (jacobian__) {
+        current_statement__ = 8;
+        sigma_b = stan::math::lub_constrain(sigma_b, 0, 100, lp__);
+      } else {
+        current_statement__ = 8;
+        sigma_b = stan::math::lub_constrain(sigma_b, 0, 100);
+      }
+      local_scalar_t__ sigma_c;
+      sigma_c = DUMMY_VAR__;
+      
+      current_statement__ = 9;
+      sigma_c = in__.scalar();
+      current_statement__ = 9;
+      if (jacobian__) {
+        current_statement__ = 9;
+        sigma_c = stan::math::lub_constrain(sigma_c, 0, 100, lp__);
+      } else {
+        current_statement__ = 9;
+        sigma_c = stan::math::lub_constrain(sigma_c, 0, 100);
+      }
+      local_scalar_t__ sigma_d;
+      sigma_d = DUMMY_VAR__;
+      
+      current_statement__ = 10;
+      sigma_d = in__.scalar();
+      current_statement__ = 10;
+      if (jacobian__) {
+        current_statement__ = 10;
+        sigma_d = stan::math::lub_constrain(sigma_d, 0, 100, lp__);
+      } else {
+        current_statement__ = 10;
+        sigma_d = stan::math::lub_constrain(sigma_d, 0, 100);
+      }
+      local_scalar_t__ sigma_e;
+      sigma_e = DUMMY_VAR__;
+      
+      current_statement__ = 11;
+      sigma_e = in__.scalar();
+      current_statement__ = 11;
+      if (jacobian__) {
+        current_statement__ = 11;
+        sigma_e = stan::math::lub_constrain(sigma_e, 0, 100, lp__);
+      } else {
+        current_statement__ = 11;
+        sigma_e = stan::math::lub_constrain(sigma_e, 0, 100);
+      }
+      current_statement__ = 12;
+      validate_non_negative_index("y_hat", "N", N);
+      Eigen::Matrix<local_scalar_t__, -1, 1> y_hat;
+      y_hat = Eigen::Matrix<local_scalar_t__, -1, 1>(N);
+      stan::math::fill(y_hat, DUMMY_VAR__);
+      
+      current_statement__ = 14;
+      if (logical_gte(N, 1)) {
+        current_statement__ = 13;
+        assign(y_hat, cons_list(index_uni(1), nil_index_list()),
+          (((((stan::math::fma(
+                 rvalue(beta, cons_list(index_uni(4), nil_index_list()),
+                   "beta"),
+                 rvalue(v_prev_full,
+                   cons_list(index_uni(1), nil_index_list()), "v_prev_full"),
+                 stan::math::fma(
+                   (rvalue(beta, cons_list(index_uni(5), nil_index_list()),
+                      "beta") *
+                     rvalue(female,
+                       cons_list(index_uni(1), nil_index_list()), "female")),
+                   rvalue(black, cons_list(index_uni(1), nil_index_list()),
+                     "black"),
+                   stan::math::fma(
+                     rvalue(beta, cons_list(index_uni(3), nil_index_list()),
+                       "beta"),
+                     rvalue(female,
+                       cons_list(index_uni(1), nil_index_list()), "female"),
+                     stan::math::fma(
+                       rvalue(beta,
+                         cons_list(index_uni(2), nil_index_list()), "beta"),
+                       rvalue(black,
+                         cons_list(index_uni(1), nil_index_list()), "black"),
+                       rvalue(beta,
+                         cons_list(index_uni(1), nil_index_list()), "beta")))))
+                +
+                rvalue(a,
+                  cons_list(
+                    index_uni(rvalue(age,
+                                cons_list(index_uni(1), nil_index_list()),
+                                "age")), nil_index_list()), "a")) +
+               rvalue(b,
+                 cons_list(
+                   index_uni(rvalue(edu,
+                               cons_list(index_uni(1), nil_index_list()),
+                               "edu")), nil_index_list()), "b")) +
+              rvalue(c,
+                cons_list(
+                  index_uni(rvalue(age_edu,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "age_edu")), nil_index_list()), "c")) +
+             rvalue(d,
+               cons_list(
+                 index_uni(rvalue(state,
+                             cons_list(index_uni(1), nil_index_list()),
+                             "state")), nil_index_list()), "d")) +
+            rvalue(e,
+              cons_list(
+                index_uni(rvalue(region_full,
+                            cons_list(index_uni(1), nil_index_list()),
+                            "region_full")), nil_index_list()), "e")),
+          "assigning variable y_hat");
+        for (int i = 2; i <= N; ++i) {
+          current_statement__ = 13;
+          assign(y_hat, cons_list(index_uni(i), nil_index_list()),
+            (((((stan::math::fma(
+                   rvalue(beta, cons_list(index_uni(4), nil_index_list()),
+                     "beta"),
+                   rvalue(v_prev_full,
+                     cons_list(index_uni(i), nil_index_list()),
+                     "v_prev_full"),
+                   stan::math::fma(
+                     (rvalue(beta, cons_list(index_uni(5), nil_index_list()),
+                        "beta") *
+                       rvalue(female,
+                         cons_list(index_uni(i), nil_index_list()), "female")),
+                     rvalue(black, cons_list(index_uni(i), nil_index_list()),
+                       "black"),
+                     stan::math::fma(
+                       rvalue(beta,
+                         cons_list(index_uni(3), nil_index_list()), "beta"),
+                       rvalue(female,
+                         cons_list(index_uni(i), nil_index_list()), "female"),
+                       stan::math::fma(
+                         rvalue(beta,
+                           cons_list(index_uni(2), nil_index_list()), "beta"),
+                         rvalue(black,
+                           cons_list(index_uni(i), nil_index_list()),
+                           "black"),
+                         rvalue(beta,
+                           cons_list(index_uni(1), nil_index_list()), "beta")))))
+                  +
+                  rvalue(a,
+                    cons_list(
+                      index_uni(rvalue(age,
+                                  cons_list(index_uni(i), nil_index_list()),
+                                  "age")), nil_index_list()), "a")) +
+                 rvalue(b,
+                   cons_list(
+                     index_uni(rvalue(edu,
+                                 cons_list(index_uni(i), nil_index_list()),
+                                 "edu")), nil_index_list()), "b")) +
+                rvalue(c,
+                  cons_list(
+                    index_uni(rvalue(age_edu,
+                                cons_list(index_uni(i), nil_index_list()),
+                                "age_edu")), nil_index_list()), "c")) +
+               rvalue(d,
+                 cons_list(
+                   index_uni(rvalue(state,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "state")), nil_index_list()), "d")) +
+              rvalue(e,
+                cons_list(
+                  index_uni(rvalue(region_full,
+                              cons_list(index_uni(i), nil_index_list()),
+                              "region_full")), nil_index_list()), "e")),
+            "assigning variable y_hat");}
+      } 
+      {
+        current_statement__ = 15;
+        lp_accum__.add(normal_log<propto__>(a, 0, sigma_a));
+        current_statement__ = 16;
+        lp_accum__.add(normal_log<propto__>(b, 0, sigma_b));
+        current_statement__ = 17;
+        lp_accum__.add(normal_log<propto__>(c, 0, sigma_c));
+        current_statement__ = 18;
+        lp_accum__.add(normal_log<propto__>(d, 0, sigma_d));
+        current_statement__ = 19;
+        lp_accum__.add(normal_log<propto__>(e, 0, sigma_e));
+        current_statement__ = 20;
+        lp_accum__.add(normal_log<propto__>(beta, 0, 100));
+        current_statement__ = 21;
+        lp_accum__.add(bernoulli_logit_log<propto__>(y, y_hat));
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "expr_prop_fail3_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym54__;
+      double lcm_sym53__;
+      double lcm_sym52__;
+      double lcm_sym51__;
+      double lcm_sym50__;
+      double lcm_sym49__;
+      double lcm_sym48__;
+      double lcm_sym47__;
+      double lcm_sym46__;
+      double lcm_sym45__;
+      double lcm_sym44__;
+      double lcm_sym43__;
+      double lcm_sym42__;
+      double lcm_sym41__;
+      double lcm_sym40__;
+      double lcm_sym39__;
+      int lcm_sym38__;
+      int lcm_sym37__;
+      int lcm_sym36__;
+      int lcm_sym35__;
+      int lcm_sym34__;
+      int lcm_sym33__;
+      int lcm_sym32__;
+      int lcm_sym31__;
+      current_statement__ = 1;
+      validate_non_negative_index("a", "n_age", n_age);
+      Eigen::Matrix<double, -1, 1> a;
+      a = Eigen::Matrix<double, -1, 1>(n_age);
+      stan::math::fill(a, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 1;
+      a = in__.vector(n_age);
+      current_statement__ = 2;
+      validate_non_negative_index("b", "n_edu", n_edu);
+      Eigen::Matrix<double, -1, 1> b;
+      b = Eigen::Matrix<double, -1, 1>(n_edu);
+      stan::math::fill(b, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 2;
+      b = in__.vector(n_edu);
+      current_statement__ = 3;
+      validate_non_negative_index("c", "n_age_edu", n_age_edu);
+      Eigen::Matrix<double, -1, 1> c;
+      c = Eigen::Matrix<double, -1, 1>(n_age_edu);
+      stan::math::fill(c, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 3;
+      c = in__.vector(n_age_edu);
+      current_statement__ = 4;
+      validate_non_negative_index("d", "n_state", n_state);
+      Eigen::Matrix<double, -1, 1> d;
+      d = Eigen::Matrix<double, -1, 1>(n_state);
+      stan::math::fill(d, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 4;
+      d = in__.vector(n_state);
+      current_statement__ = 5;
+      validate_non_negative_index("e", "n_region_full", n_region_full);
+      Eigen::Matrix<double, -1, 1> e;
+      e = Eigen::Matrix<double, -1, 1>(n_region_full);
+      stan::math::fill(e, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 5;
+      e = in__.vector(n_region_full);
+      current_statement__ = 6;
+      validate_non_negative_index("beta", "5", 5);
+      Eigen::Matrix<double, -1, 1> beta;
+      beta = Eigen::Matrix<double, -1, 1>(5);
+      stan::math::fill(beta, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 6;
+      beta = in__.vector(5);
+      double sigma_a;
+      sigma_a = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 7;
+      sigma_a = in__.scalar();
+      current_statement__ = 7;
+      sigma_a = stan::math::lub_constrain(sigma_a, 0, 100);
+      double sigma_b;
+      sigma_b = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 8;
+      sigma_b = in__.scalar();
+      current_statement__ = 8;
+      sigma_b = stan::math::lub_constrain(sigma_b, 0, 100);
+      double sigma_c;
+      sigma_c = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 9;
+      sigma_c = in__.scalar();
+      current_statement__ = 9;
+      sigma_c = stan::math::lub_constrain(sigma_c, 0, 100);
+      double sigma_d;
+      sigma_d = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 10;
+      sigma_d = in__.scalar();
+      current_statement__ = 10;
+      sigma_d = stan::math::lub_constrain(sigma_d, 0, 100);
+      double sigma_e;
+      sigma_e = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 11;
+      sigma_e = in__.scalar();
+      current_statement__ = 11;
+      sigma_e = stan::math::lub_constrain(sigma_e, 0, 100);
+      current_statement__ = 12;
+      validate_non_negative_index("y_hat", "N", N);
+      Eigen::Matrix<local_scalar_t__, -1, 1> y_hat;
+      y_hat = Eigen::Matrix<local_scalar_t__, -1, 1>(N);
+      stan::math::fill(y_hat, DUMMY_VAR__);
+      
+      if (logical_gte(n_age, 1)) {
+        vars__.push_back(
+          rvalue(a, cons_list(index_uni(1), nil_index_list()), "a"));
+        for (int sym1__ = 2; sym1__ <= n_age; ++sym1__) {
+          vars__.push_back(a[(sym1__ - 1)]);}
+      } 
+      if (logical_gte(n_edu, 1)) {
+        vars__.push_back(
+          rvalue(b, cons_list(index_uni(1), nil_index_list()), "b"));
+        for (int sym1__ = 2; sym1__ <= n_edu; ++sym1__) {
+          vars__.push_back(b[(sym1__ - 1)]);}
+      } 
+      if (logical_gte(n_age_edu, 1)) {
+        vars__.push_back(
+          rvalue(c, cons_list(index_uni(1), nil_index_list()), "c"));
+        for (int sym1__ = 2; sym1__ <= n_age_edu; ++sym1__) {
+          vars__.push_back(c[(sym1__ - 1)]);}
+      } 
+      if (logical_gte(n_state, 1)) {
+        vars__.push_back(
+          rvalue(d, cons_list(index_uni(1), nil_index_list()), "d"));
+        for (int sym1__ = 2; sym1__ <= n_state; ++sym1__) {
+          vars__.push_back(d[(sym1__ - 1)]);}
+      } 
+      if (logical_gte(n_region_full, 1)) {
+        vars__.push_back(
+          rvalue(e, cons_list(index_uni(1), nil_index_list()), "e"));
+        for (int sym1__ = 2; sym1__ <= n_region_full; ++sym1__) {
+          vars__.push_back(e[(sym1__ - 1)]);}
+      } 
+      {
+        vars__.push_back(
+          rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"));
+        {
+          vars__.push_back(
+            rvalue(beta, cons_list(index_uni(2), nil_index_list()), "beta"));
+        }
+        {
+          vars__.push_back(
+            rvalue(beta, cons_list(index_uni(3), nil_index_list()), "beta"));
+        }
+        {
+          vars__.push_back(
+            rvalue(beta, cons_list(index_uni(4), nil_index_list()), "beta"));
+        }
+        {
+          vars__.push_back(
+            rvalue(beta, cons_list(index_uni(5), nil_index_list()), "beta"));
+        }
+      }
+      vars__.push_back(sigma_a);
+      vars__.push_back(sigma_b);
+      vars__.push_back(sigma_c);
+      vars__.push_back(sigma_d);
+      vars__.push_back(sigma_e);
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      lcm_sym31__ = logical_gte(N, 1);
+      if (lcm_sym31__) {
+        current_statement__ = 13;
+        assign(y_hat, cons_list(index_uni(1), nil_index_list()),
+          (((((stan::math::fma(
+                 rvalue(beta, cons_list(index_uni(4), nil_index_list()),
+                   "beta"),
+                 rvalue(v_prev_full,
+                   cons_list(index_uni(1), nil_index_list()), "v_prev_full"),
+                 stan::math::fma(
+                   (rvalue(beta, cons_list(index_uni(5), nil_index_list()),
+                      "beta") *
+                     rvalue(female,
+                       cons_list(index_uni(1), nil_index_list()), "female")),
+                   rvalue(black, cons_list(index_uni(1), nil_index_list()),
+                     "black"),
+                   stan::math::fma(
+                     rvalue(beta, cons_list(index_uni(3), nil_index_list()),
+                       "beta"),
+                     rvalue(female,
+                       cons_list(index_uni(1), nil_index_list()), "female"),
+                     stan::math::fma(
+                       rvalue(beta,
+                         cons_list(index_uni(2), nil_index_list()), "beta"),
+                       rvalue(black,
+                         cons_list(index_uni(1), nil_index_list()), "black"),
+                       rvalue(beta,
+                         cons_list(index_uni(1), nil_index_list()), "beta")))))
+                +
+                rvalue(a,
+                  cons_list(
+                    index_uni(rvalue(age,
+                                cons_list(index_uni(1), nil_index_list()),
+                                "age")), nil_index_list()), "a")) +
+               rvalue(b,
+                 cons_list(
+                   index_uni(rvalue(edu,
+                               cons_list(index_uni(1), nil_index_list()),
+                               "edu")), nil_index_list()), "b")) +
+              rvalue(c,
+                cons_list(
+                  index_uni(rvalue(age_edu,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "age_edu")), nil_index_list()), "c")) +
+             rvalue(d,
+               cons_list(
+                 index_uni(rvalue(state,
+                             cons_list(index_uni(1), nil_index_list()),
+                             "state")), nil_index_list()), "d")) +
+            rvalue(e,
+              cons_list(
+                index_uni(rvalue(region_full,
+                            cons_list(index_uni(1), nil_index_list()),
+                            "region_full")), nil_index_list()), "e")),
+          "assigning variable y_hat");
+        for (int i = 2; i <= N; ++i) {
+          current_statement__ = 13;
+          assign(y_hat, cons_list(index_uni(i), nil_index_list()),
+            (((((stan::math::fma(
+                   rvalue(beta, cons_list(index_uni(4), nil_index_list()),
+                     "beta"),
+                   rvalue(v_prev_full,
+                     cons_list(index_uni(i), nil_index_list()),
+                     "v_prev_full"),
+                   stan::math::fma(
+                     (rvalue(beta, cons_list(index_uni(5), nil_index_list()),
+                        "beta") *
+                       rvalue(female,
+                         cons_list(index_uni(i), nil_index_list()), "female")),
+                     rvalue(black, cons_list(index_uni(i), nil_index_list()),
+                       "black"),
+                     stan::math::fma(
+                       rvalue(beta,
+                         cons_list(index_uni(3), nil_index_list()), "beta"),
+                       rvalue(female,
+                         cons_list(index_uni(i), nil_index_list()), "female"),
+                       stan::math::fma(
+                         rvalue(beta,
+                           cons_list(index_uni(2), nil_index_list()), "beta"),
+                         rvalue(black,
+                           cons_list(index_uni(i), nil_index_list()),
+                           "black"),
+                         rvalue(beta,
+                           cons_list(index_uni(1), nil_index_list()), "beta")))))
+                  +
+                  rvalue(a,
+                    cons_list(
+                      index_uni(rvalue(age,
+                                  cons_list(index_uni(i), nil_index_list()),
+                                  "age")), nil_index_list()), "a")) +
+                 rvalue(b,
+                   cons_list(
+                     index_uni(rvalue(edu,
+                                 cons_list(index_uni(i), nil_index_list()),
+                                 "edu")), nil_index_list()), "b")) +
+                rvalue(c,
+                  cons_list(
+                    index_uni(rvalue(age_edu,
+                                cons_list(index_uni(i), nil_index_list()),
+                                "age_edu")), nil_index_list()), "c")) +
+               rvalue(d,
+                 cons_list(
+                   index_uni(rvalue(state,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "state")), nil_index_list()), "d")) +
+              rvalue(e,
+                cons_list(
+                  index_uni(rvalue(region_full,
+                              cons_list(index_uni(i), nil_index_list()),
+                              "region_full")), nil_index_list()), "e")),
+            "assigning variable y_hat");}
+      } 
+      if (lcm_sym31__) {
+        vars__.push_back(
+          rvalue(y_hat, cons_list(index_uni(1), nil_index_list()), "y_hat"));
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          vars__.push_back(y_hat[(sym1__ - 1)]);}
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym30__;
+      double lcm_sym29__;
+      double lcm_sym28__;
+      double lcm_sym27__;
+      double lcm_sym26__;
+      double lcm_sym25__;
+      double lcm_sym24__;
+      double lcm_sym23__;
+      double lcm_sym22__;
+      double lcm_sym21__;
+      double lcm_sym20__;
+      double lcm_sym19__;
+      double lcm_sym18__;
+      double lcm_sym17__;
+      double lcm_sym16__;
+      double lcm_sym15__;
+      double lcm_sym14__;
+      double lcm_sym13__;
+      double lcm_sym12__;
+      double lcm_sym11__;
+      double lcm_sym10__;
+      double lcm_sym9__;
+      double lcm_sym8__;
+      double lcm_sym7__;
+      int lcm_sym6__;
+      int lcm_sym5__;
+      int lcm_sym4__;
+      int lcm_sym3__;
+      int lcm_sym2__;
+      int lcm_sym1__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      current_statement__ = 1;
+      validate_non_negative_index("a", "n_age", n_age);
+      Eigen::Matrix<double, -1, 1> a;
+      a = Eigen::Matrix<double, -1, 1>(n_age);
+      stan::math::fill(a, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> a_flat__;
+        current_statement__ = 1;
+        assign(a_flat__, nil_index_list(), context__.vals_r("a"),
+          "assigning variable a_flat__");
+        current_statement__ = 1;
+        pos__ = 1;
+        lcm_sym1__ = logical_gte(n_age, 1);
+        if (lcm_sym1__) {
+          current_statement__ = 1;
+          assign(a, cons_list(index_uni(1), nil_index_list()),
+            rvalue(a_flat__, cons_list(index_uni(1), nil_index_list()),
+              "a_flat__"), "assigning variable a");
+          current_statement__ = 1;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= n_age; ++sym1__) {
+            current_statement__ = 1;
+            assign(a, cons_list(index_uni(sym1__), nil_index_list()),
+              a_flat__[(pos__ - 1)], "assigning variable a");
+            current_statement__ = 1;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 2;
+      validate_non_negative_index("b", "n_edu", n_edu);
+      Eigen::Matrix<double, -1, 1> b;
+      b = Eigen::Matrix<double, -1, 1>(n_edu);
+      stan::math::fill(b, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> b_flat__;
+        current_statement__ = 2;
+        assign(b_flat__, nil_index_list(), context__.vals_r("b"),
+          "assigning variable b_flat__");
+        current_statement__ = 2;
+        pos__ = 1;
+        lcm_sym3__ = logical_gte(n_edu, 1);
+        if (lcm_sym3__) {
+          current_statement__ = 2;
+          assign(b, cons_list(index_uni(1), nil_index_list()),
+            rvalue(b_flat__, cons_list(index_uni(1), nil_index_list()),
+              "b_flat__"), "assigning variable b");
+          current_statement__ = 2;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= n_edu; ++sym1__) {
+            current_statement__ = 2;
+            assign(b, cons_list(index_uni(sym1__), nil_index_list()),
+              b_flat__[(pos__ - 1)], "assigning variable b");
+            current_statement__ = 2;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 3;
+      validate_non_negative_index("c", "n_age_edu", n_age_edu);
+      Eigen::Matrix<double, -1, 1> c;
+      c = Eigen::Matrix<double, -1, 1>(n_age_edu);
+      stan::math::fill(c, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> c_flat__;
+        current_statement__ = 3;
+        assign(c_flat__, nil_index_list(), context__.vals_r("c"),
+          "assigning variable c_flat__");
+        current_statement__ = 3;
+        pos__ = 1;
+        lcm_sym2__ = logical_gte(n_age_edu, 1);
+        if (lcm_sym2__) {
+          current_statement__ = 3;
+          assign(c, cons_list(index_uni(1), nil_index_list()),
+            rvalue(c_flat__, cons_list(index_uni(1), nil_index_list()),
+              "c_flat__"), "assigning variable c");
+          current_statement__ = 3;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= n_age_edu; ++sym1__) {
+            current_statement__ = 3;
+            assign(c, cons_list(index_uni(sym1__), nil_index_list()),
+              c_flat__[(pos__ - 1)], "assigning variable c");
+            current_statement__ = 3;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 4;
+      validate_non_negative_index("d", "n_state", n_state);
+      Eigen::Matrix<double, -1, 1> d;
+      d = Eigen::Matrix<double, -1, 1>(n_state);
+      stan::math::fill(d, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> d_flat__;
+        current_statement__ = 4;
+        assign(d_flat__, nil_index_list(), context__.vals_r("d"),
+          "assigning variable d_flat__");
+        current_statement__ = 4;
+        pos__ = 1;
+        lcm_sym5__ = logical_gte(n_state, 1);
+        if (lcm_sym5__) {
+          current_statement__ = 4;
+          assign(d, cons_list(index_uni(1), nil_index_list()),
+            rvalue(d_flat__, cons_list(index_uni(1), nil_index_list()),
+              "d_flat__"), "assigning variable d");
+          current_statement__ = 4;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= n_state; ++sym1__) {
+            current_statement__ = 4;
+            assign(d, cons_list(index_uni(sym1__), nil_index_list()),
+              d_flat__[(pos__ - 1)], "assigning variable d");
+            current_statement__ = 4;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 5;
+      validate_non_negative_index("e", "n_region_full", n_region_full);
+      Eigen::Matrix<double, -1, 1> e;
+      e = Eigen::Matrix<double, -1, 1>(n_region_full);
+      stan::math::fill(e, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> e_flat__;
+        current_statement__ = 5;
+        assign(e_flat__, nil_index_list(), context__.vals_r("e"),
+          "assigning variable e_flat__");
+        current_statement__ = 5;
+        pos__ = 1;
+        lcm_sym4__ = logical_gte(n_region_full, 1);
+        if (lcm_sym4__) {
+          current_statement__ = 5;
+          assign(e, cons_list(index_uni(1), nil_index_list()),
+            rvalue(e_flat__, cons_list(index_uni(1), nil_index_list()),
+              "e_flat__"), "assigning variable e");
+          current_statement__ = 5;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= n_region_full; ++sym1__) {
+            current_statement__ = 5;
+            assign(e, cons_list(index_uni(sym1__), nil_index_list()),
+              e_flat__[(pos__ - 1)], "assigning variable e");
+            current_statement__ = 5;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 6;
+      validate_non_negative_index("beta", "5", 5);
+      Eigen::Matrix<double, -1, 1> beta;
+      beta = Eigen::Matrix<double, -1, 1>(5);
+      stan::math::fill(beta, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> beta_flat__;
+        current_statement__ = 6;
+        assign(beta_flat__, nil_index_list(), context__.vals_r("beta"),
+          "assigning variable beta_flat__");
+        current_statement__ = 6;
+        pos__ = 1;
+        {
+          current_statement__ = 6;
+          assign(beta, cons_list(index_uni(1), nil_index_list()),
+            rvalue(beta_flat__, cons_list(index_uni(1), nil_index_list()),
+              "beta_flat__"), "assigning variable beta");
+          current_statement__ = 6;
+          pos__ = 2;
+          {
+            current_statement__ = 6;
+            assign(beta, cons_list(index_uni(2), nil_index_list()),
+              beta_flat__[(pos__ - 1)], "assigning variable beta");
+            current_statement__ = 6;
+            pos__ = (pos__ + 1);
+          }
+          {
+            current_statement__ = 6;
+            assign(beta, cons_list(index_uni(3), nil_index_list()),
+              beta_flat__[(pos__ - 1)], "assigning variable beta");
+            current_statement__ = 6;
+            pos__ = (pos__ + 1);
+          }
+          {
+            current_statement__ = 6;
+            assign(beta, cons_list(index_uni(4), nil_index_list()),
+              beta_flat__[(pos__ - 1)], "assigning variable beta");
+            current_statement__ = 6;
+            pos__ = (pos__ + 1);
+          }
+          {
+            current_statement__ = 6;
+            assign(beta, cons_list(index_uni(5), nil_index_list()),
+              beta_flat__[(pos__ - 1)], "assigning variable beta");
+            current_statement__ = 6;
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      double sigma_a;
+      sigma_a = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 7;
+      sigma_a = context__.vals_r("sigma_a")[(1 - 1)];
+      current_statement__ = 7;
+      sigma_a = stan::math::lub_free(sigma_a, 0, 100);
+      double sigma_b;
+      sigma_b = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 8;
+      sigma_b = context__.vals_r("sigma_b")[(1 - 1)];
+      current_statement__ = 8;
+      sigma_b = stan::math::lub_free(sigma_b, 0, 100);
+      double sigma_c;
+      sigma_c = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 9;
+      sigma_c = context__.vals_r("sigma_c")[(1 - 1)];
+      current_statement__ = 9;
+      sigma_c = stan::math::lub_free(sigma_c, 0, 100);
+      double sigma_d;
+      sigma_d = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 10;
+      sigma_d = context__.vals_r("sigma_d")[(1 - 1)];
+      current_statement__ = 10;
+      sigma_d = stan::math::lub_free(sigma_d, 0, 100);
+      double sigma_e;
+      sigma_e = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 11;
+      sigma_e = context__.vals_r("sigma_e")[(1 - 1)];
+      current_statement__ = 11;
+      sigma_e = stan::math::lub_free(sigma_e, 0, 100);
+      if (lcm_sym1__) {
+        vars__.push_back(
+          rvalue(a, cons_list(index_uni(1), nil_index_list()), "a"));
+        for (int sym1__ = 2; sym1__ <= n_age; ++sym1__) {
+          vars__.push_back(a[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym3__) {
+        vars__.push_back(
+          rvalue(b, cons_list(index_uni(1), nil_index_list()), "b"));
+        for (int sym1__ = 2; sym1__ <= n_edu; ++sym1__) {
+          vars__.push_back(b[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym2__) {
+        vars__.push_back(
+          rvalue(c, cons_list(index_uni(1), nil_index_list()), "c"));
+        for (int sym1__ = 2; sym1__ <= n_age_edu; ++sym1__) {
+          vars__.push_back(c[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym5__) {
+        vars__.push_back(
+          rvalue(d, cons_list(index_uni(1), nil_index_list()), "d"));
+        for (int sym1__ = 2; sym1__ <= n_state; ++sym1__) {
+          vars__.push_back(d[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym4__) {
+        vars__.push_back(
+          rvalue(e, cons_list(index_uni(1), nil_index_list()), "e"));
+        for (int sym1__ = 2; sym1__ <= n_region_full; ++sym1__) {
+          vars__.push_back(e[(sym1__ - 1)]);}
+      } 
+      {
+        vars__.push_back(
+          rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"));
+        {
+          vars__.push_back(
+            rvalue(beta, cons_list(index_uni(2), nil_index_list()), "beta"));
+        }
+        {
+          vars__.push_back(
+            rvalue(beta, cons_list(index_uni(3), nil_index_list()), "beta"));
+        }
+        {
+          vars__.push_back(
+            rvalue(beta, cons_list(index_uni(4), nil_index_list()), "beta"));
+        }
+        {
+          vars__.push_back(
+            rvalue(beta, cons_list(index_uni(5), nil_index_list()), "beta"));
+        }
+      }
+      vars__.push_back(sigma_a);
+      vars__.push_back(sigma_b);
+      vars__.push_back(sigma_c);
+      vars__.push_back(sigma_d);
+      vars__.push_back(sigma_e);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("a");
+    names__.push_back("b");
+    names__.push_back("c");
+    names__.push_back("d");
+    names__.push_back("e");
+    names__.push_back("beta");
+    names__.push_back("sigma_a");
+    names__.push_back("sigma_b");
+    names__.push_back("sigma_c");
+    names__.push_back("sigma_d");
+    names__.push_back("sigma_e");
+    names__.push_back("y_hat");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dims__.push_back(n_age);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_edu);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_age_edu);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_state);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_region_full);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(5);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(N);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    for (int sym85__ = 1; sym85__ <= n_age; ++sym85__) {
+      {
+        param_names__.push_back(std::string() + "a" + '.' + std::to_string(sym85__));
+      }}
+    for (int sym85__ = 1; sym85__ <= n_edu; ++sym85__) {
+      {
+        param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym85__));
+      }}
+    for (int sym85__ = 1; sym85__ <= n_age_edu; ++sym85__) {
+      {
+        param_names__.push_back(std::string() + "c" + '.' + std::to_string(sym85__));
+      }}
+    for (int sym85__ = 1; sym85__ <= n_state; ++sym85__) {
+      {
+        param_names__.push_back(std::string() + "d" + '.' + std::to_string(sym85__));
+      }}
+    for (int sym85__ = 1; sym85__ <= n_region_full; ++sym85__) {
+      {
+        param_names__.push_back(std::string() + "e" + '.' + std::to_string(sym85__));
+      }}
+    for (int sym85__ = 1; sym85__ <= 5; ++sym85__) {
+      {
+        param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym85__));
+      }}
+    param_names__.push_back(std::string() + "sigma_a");
+    param_names__.push_back(std::string() + "sigma_b");
+    param_names__.push_back(std::string() + "sigma_c");
+    param_names__.push_back(std::string() + "sigma_d");
+    param_names__.push_back(std::string() + "sigma_e");
+    if (emit_transformed_parameters__) {
+      for (int sym85__ = 1; sym85__ <= N; ++sym85__) {
+        {
+          param_names__.push_back(std::string() + "y_hat" + '.' + std::to_string(sym85__));
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    for (int sym85__ = 1; sym85__ <= n_age; ++sym85__) {
+      {
+        param_names__.push_back(std::string() + "a" + '.' + std::to_string(sym85__));
+      }}
+    for (int sym85__ = 1; sym85__ <= n_edu; ++sym85__) {
+      {
+        param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym85__));
+      }}
+    for (int sym85__ = 1; sym85__ <= n_age_edu; ++sym85__) {
+      {
+        param_names__.push_back(std::string() + "c" + '.' + std::to_string(sym85__));
+      }}
+    for (int sym85__ = 1; sym85__ <= n_state; ++sym85__) {
+      {
+        param_names__.push_back(std::string() + "d" + '.' + std::to_string(sym85__));
+      }}
+    for (int sym85__ = 1; sym85__ <= n_region_full; ++sym85__) {
+      {
+        param_names__.push_back(std::string() + "e" + '.' + std::to_string(sym85__));
+      }}
+    for (int sym85__ = 1; sym85__ <= 5; ++sym85__) {
+      {
+        param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym85__));
+      }}
+    param_names__.push_back(std::string() + "sigma_a");
+    param_names__.push_back(std::string() + "sigma_b");
+    param_names__.push_back(std::string() + "sigma_c");
+    param_names__.push_back(std::string() + "sigma_d");
+    param_names__.push_back(std::string() + "sigma_e");
+    if (emit_transformed_parameters__) {
+      for (int sym85__ = 1; sym85__ <= N; ++sym85__) {
+        {
+          param_names__.push_back(std::string() + "y_hat" + '.' + std::to_string(sym85__));
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"a\",\"type\":{\"name\":\"vector\",\"length\":" << n_age << "},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" << n_edu << "},\"block\":\"parameters\"},{\"name\":\"c\",\"type\":{\"name\":\"vector\",\"length\":" << n_age_edu << "},\"block\":\"parameters\"},{\"name\":\"d\",\"type\":{\"name\":\"vector\",\"length\":" << n_state << "},\"block\":\"parameters\"},{\"name\":\"e\",\"type\":{\"name\":\"vector\",\"length\":" << n_region_full << "},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << 5 << "},\"block\":\"parameters\"},{\"name\":\"sigma_a\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_b\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_c\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_d\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_e\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"a\",\"type\":{\"name\":\"vector\",\"length\":" << n_age << "},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" << n_edu << "},\"block\":\"parameters\"},{\"name\":\"c\",\"type\":{\"name\":\"vector\",\"length\":" << n_age_edu << "},\"block\":\"parameters\"},{\"name\":\"d\",\"type\":{\"name\":\"vector\",\"length\":" << n_state << "},\"block\":\"parameters\"},{\"name\":\"e\",\"type\":{\"name\":\"vector\",\"length\":" << n_region_full << "},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << 5 << "},\"block\":\"parameters\"},{\"name\":\"sigma_a\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_b\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_c\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_d\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_e\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef expr_prop_fail3_model_namespace::expr_prop_fail3_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail4.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace expr_prop_fail4_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'expr-prop-fail4.stan', line 12, column 2 to column 24)",
+                                                      " (in 'expr-prop-fail4.stan', line 13, column 2 to column 28)",
+                                                      " (in 'expr-prop-fail4.stan', line 16, column 2 to column 47)",
+                                                      " (in 'expr-prop-fail4.stan', line 17, column 2 to column 16)",
+                                                      " (in 'expr-prop-fail4.stan', line 18, column 2 to column 31)",
+                                                      " (in 'expr-prop-fail4.stan', line 19, column 2 to column 29)",
+                                                      " (in 'expr-prop-fail4.stan', line 20, column 2 to column 24)",
+                                                      " (in 'expr-prop-fail4.stan', line 27, column 2 to column 13)",
+                                                      " (in 'expr-prop-fail4.stan', line 28, column 2 to column 13)",
+                                                      " (in 'expr-prop-fail4.stan', line 29, column 2 to column 26)",
+                                                      " (in 'expr-prop-fail4.stan', line 30, column 2 to column 28)",
+                                                      " (in 'expr-prop-fail4.stan', line 31, column 2 to column 18)",
+                                                      " (in 'expr-prop-fail4.stan', line 32, column 2 to column 22)",
+                                                      " (in 'expr-prop-fail4.stan', line 34, column 2 to column 14)",
+                                                      " (in 'expr-prop-fail4.stan', line 35, column 2 to column 11)",
+                                                      " (in 'expr-prop-fail4.stan', line 37, column 2 to column 27)",
+                                                      " (in 'expr-prop-fail4.stan', line 38, column 2 to column 27)",
+                                                      " (in 'expr-prop-fail4.stan', line 40, column 4 to column 36)",
+                                                      " (in 'expr-prop-fail4.stan', line 39, column 17 to line 41, column 3)",
+                                                      " (in 'expr-prop-fail4.stan', line 39, column 2 to line 41, column 3)",
+                                                      " (in 'expr-prop-fail4.stan', line 42, column 2 to column 38)",
+                                                      " (in 'expr-prop-fail4.stan', line 47, column 4 to column 28)",
+                                                      " (in 'expr-prop-fail4.stan', line 48, column 4 to column 80)",
+                                                      " (in 'expr-prop-fail4.stan', line 46, column 17 to line 49, column 3)",
+                                                      " (in 'expr-prop-fail4.stan', line 46, column 2 to line 49, column 3)",
+                                                      " (in 'expr-prop-fail4.stan', line 23, column 2 to column 53)",
+                                                      " (in 'expr-prop-fail4.stan', line 24, column 2 to column 24)",
+                                                      " (in 'expr-prop-fail4.stan', line 2, column 2 to column 17)",
+                                                      " (in 'expr-prop-fail4.stan', line 3, column 2 to column 23)",
+                                                      " (in 'expr-prop-fail4.stan', line 4, column 2 to column 39)",
+                                                      " (in 'expr-prop-fail4.stan', line 5, column 2 to column 39)",
+                                                      " (in 'expr-prop-fail4.stan', line 6, column 2 to column 23)",
+                                                      " (in 'expr-prop-fail4.stan', line 9, column 2 to column 27)"};
+
+
+
+class expr_prop_fail4_model : public model_base_crtp<expr_prop_fail4_model> {
+
+ private:
+  int lcm_sym49__;
+  int lcm_sym48__;
+  int lcm_sym47__;
+  int lcm_sym46__;
+  double lcm_sym45__;
+  double lcm_sym44__;
+  Eigen::Matrix<double, -1, 1> lcm_sym43__;
+  int lcm_sym42__;
+  int lcm_sym41__;
+  int lcm_sym40__;
+  int pos__;
+  int N;
+  int N_edges;
+  std::vector<int> node1;
+  std::vector<int> node2;
+  Eigen::Matrix<double, -1, 1> E;
+  Eigen::Matrix<double, -1, 1> log_E;
+ 
+ public:
+  ~expr_prop_fail4_model() { }
+  
+  std::string model_name() const { return "expr_prop_fail4_model"; }
+  
+  expr_prop_fail4_model(stan::io::var_context& context__,
+                        unsigned int random_seed__ = 0,
+                        std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "expr_prop_fail4_model_namespace::expr_prop_fail4_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","N","int",
+          context__.to_vec());
+      N = std::numeric_limits<int>::min();
+      
+      current_statement__ = 28;
+      N = context__.vals_i("N")[(1 - 1)];
+      context__.validate_dims("data initialization","N_edges","int",
+          context__.to_vec());
+      N_edges = std::numeric_limits<int>::min();
+      
+      current_statement__ = 29;
+      N_edges = context__.vals_i("N_edges")[(1 - 1)];
+      current_statement__ = 30;
+      validate_non_negative_index("node1", "N_edges", N_edges);
+      context__.validate_dims("data initialization","node1","int",
+          context__.to_vec(N_edges));
+      node1 = std::vector<int>(N_edges, std::numeric_limits<int>::min());
+      
+      current_statement__ = 30;
+      assign(node1, nil_index_list(), context__.vals_i("node1"),
+        "assigning variable node1");
+      current_statement__ = 31;
+      validate_non_negative_index("node2", "N_edges", N_edges);
+      context__.validate_dims("data initialization","node2","int",
+          context__.to_vec(N_edges));
+      node2 = std::vector<int>(N_edges, std::numeric_limits<int>::min());
+      
+      current_statement__ = 31;
+      assign(node2, nil_index_list(), context__.vals_i("node2"),
+        "assigning variable node2");
+      current_statement__ = 32;
+      validate_non_negative_index("E", "N", N);
+      context__.validate_dims("data initialization","E","double",
+          context__.to_vec(N));
+      E = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(E, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> E_flat__;
+        current_statement__ = 32;
+        assign(E_flat__, nil_index_list(), context__.vals_r("E"),
+          "assigning variable E_flat__");
+        current_statement__ = 32;
+        pos__ = 1;
+        current_statement__ = 32;
+        if (logical_gte(N, 1)) {
+          current_statement__ = 32;
+          assign(E, cons_list(index_uni(1), nil_index_list()),
+            rvalue(E_flat__, cons_list(index_uni(1), nil_index_list()),
+              "E_flat__"), "assigning variable E");
+          current_statement__ = 32;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 32;
+            assign(E, cons_list(index_uni(sym1__), nil_index_list()),
+              E_flat__[(pos__ - 1)], "assigning variable E");
+            current_statement__ = 32;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 33;
+      validate_non_negative_index("log_E", "N", N);
+      log_E = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(log_E, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 33;
+      assign(log_E, nil_index_list(), stan::math::log(E),
+        "assigning variable log_E");
+      current_statement__ = 28;
+      current_statement__ = 28;
+      check_greater_or_equal(function__, "N", N, 0);
+      current_statement__ = 29;
+      current_statement__ = 29;
+      check_greater_or_equal(function__, "N_edges", N_edges, 0);
+      lcm_sym41__ = logical_gte(N_edges, 1);
+      if (lcm_sym41__) {
+        current_statement__ = 30;
+        current_statement__ = 30;
+        check_greater_or_equal(function__, "node1[sym1__]",
+                               rvalue(node1,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "node1"), 1);
+        for (int sym1__ = 2; sym1__ <= N_edges; ++sym1__) {
+          current_statement__ = 30;
+          current_statement__ = 30;
+          check_greater_or_equal(function__, "node1[sym1__]",
+                                 node1[(sym1__ - 1)], 1);}
+      } 
+      current_statement__ = 30;
+      if (lcm_sym41__) {
+        current_statement__ = 30;
+        current_statement__ = 30;
+        check_less_or_equal(function__, "node1[sym1__]",
+                            rvalue(node1,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "node1"), N);
+        for (int sym1__ = 2; sym1__ <= N_edges; ++sym1__) {
+          current_statement__ = 30;
+          current_statement__ = 30;
+          check_less_or_equal(function__, "node1[sym1__]",
+                              node1[(sym1__ - 1)], N);}
+      } 
+      current_statement__ = 31;
+      if (lcm_sym41__) {
+        current_statement__ = 31;
+        current_statement__ = 31;
+        check_greater_or_equal(function__, "node2[sym1__]",
+                               rvalue(node2,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "node2"), 1);
+        for (int sym1__ = 2; sym1__ <= N_edges; ++sym1__) {
+          current_statement__ = 31;
+          current_statement__ = 31;
+          check_greater_or_equal(function__, "node2[sym1__]",
+                                 node2[(sym1__ - 1)], 1);}
+      } 
+      current_statement__ = 31;
+      if (lcm_sym41__) {
+        current_statement__ = 31;
+        current_statement__ = 31;
+        check_less_or_equal(function__, "node2[sym1__]",
+                            rvalue(node2,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "node2"), N);
+        for (int sym1__ = 2; sym1__ <= N_edges; ++sym1__) {
+          current_statement__ = 31;
+          current_statement__ = 31;
+          check_less_or_equal(function__, "node2[sym1__]",
+                              node2[(sym1__ - 1)], N);}
+      } 
+      current_statement__ = 32;
+      current_statement__ = 32;
+      check_greater_or_equal(function__, "E", E, 0);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      current_statement__ = 2;
+      validate_non_negative_index("phi_std_raw", "(N - 1)", (N - 1));
+      num_params_r__ += (N - 1);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "expr_prop_fail4_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      local_scalar_t__ lcm_sym38__;
+      double lcm_sym37__;
+      double lcm_sym36__;
+      Eigen::Matrix<double, -1, 1> lcm_sym35__;
+      double lcm_sym34__;
+      int lcm_sym39__;
+      local_scalar_t__ tau_phi;
+      tau_phi = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      tau_phi = in__.scalar();
+      current_statement__ = 1;
+      if (jacobian__) {
+        current_statement__ = 1;
+        tau_phi = stan::math::lb_constrain(tau_phi, 0, lp__);
+      } else {
+        current_statement__ = 1;
+        tau_phi = stan::math::lb_constrain(tau_phi, 0);
+      }
+      lcm_sym39__ = (N - 1);
+      validate_non_negative_index("phi_std_raw", "(N - 1)", lcm_sym39__);
+      Eigen::Matrix<local_scalar_t__, -1, 1> phi_std_raw;
+      phi_std_raw = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym39__);
+      stan::math::fill(phi_std_raw, DUMMY_VAR__);
+      
+      current_statement__ = 2;
+      phi_std_raw = in__.vector(lcm_sym39__);
+      local_scalar_t__ sigma_phi;
+      sigma_phi = DUMMY_VAR__;
+      
+      lcm_sym38__ = inv_sqrt(tau_phi);
+      sigma_phi = lcm_sym38__;
+      current_statement__ = 4;
+      validate_non_negative_index("phi", "N", N);
+      Eigen::Matrix<local_scalar_t__, -1, 1> phi;
+      phi = Eigen::Matrix<local_scalar_t__, -1, 1>(N);
+      stan::math::fill(phi, DUMMY_VAR__);
+      
+      current_statement__ = 5;
+      assign(phi, cons_list(index_min_max(1, lcm_sym39__), nil_index_list()),
+        phi_std_raw, "assigning variable phi");
+      current_statement__ = 6;
+      assign(phi, cons_list(index_uni(N), nil_index_list()),
+        -sum(phi_std_raw), "assigning variable phi");
+      current_statement__ = 7;
+      assign(phi, nil_index_list(),
+        multiply(stan::model::deep_copy(phi), lcm_sym38__),
+        "assigning variable phi");
+      current_statement__ = 3;
+      current_statement__ = 3;
+      check_greater_or_equal(function__, "sigma_phi", lcm_sym38__, 0);
+      {
+        current_statement__ = 26;
+        lp_accum__.add(
+          (-0.5 *
+            dot_self(
+              subtract(
+                rvalue(phi, cons_list(index_multi(node1), nil_index_list()),
+                  "phi"),
+                rvalue(phi, cons_list(index_multi(node2), nil_index_list()),
+                  "phi")))));
+        current_statement__ = 27;
+        lp_accum__.add(gamma_log<propto__>(tau_phi, 1, 1));
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "expr_prop_fail4_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym32__;
+      double lcm_sym31__;
+      int lcm_sym30__;
+      int lcm_sym29__;
+      double lcm_sym28__;
+      double lcm_sym27__;
+      double lcm_sym26__;
+      double lcm_sym25__;
+      double lcm_sym24__;
+      double lcm_sym23__;
+      double lcm_sym22__;
+      double lcm_sym21__;
+      double lcm_sym17__;
+      double lcm_sym16__;
+      Eigen::Matrix<double, -1, 1> lcm_sym15__;
+      Eigen::Matrix<double, -1, 1> lcm_sym14__;
+      double lcm_sym19__;
+      double lcm_sym18__;
+      int lcm_sym13__;
+      int lcm_sym12__;
+      double lcm_sym11__;
+      int lcm_sym20__;
+      int lcm_sym9__;
+      int lcm_sym8__;
+      double tau_phi;
+      tau_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      tau_phi = in__.scalar();
+      current_statement__ = 1;
+      tau_phi = stan::math::lb_constrain(tau_phi, 0);
+      lcm_sym20__ = (N - 1);
+      validate_non_negative_index("phi_std_raw", "(N - 1)", lcm_sym20__);
+      Eigen::Matrix<double, -1, 1> phi_std_raw;
+      phi_std_raw = Eigen::Matrix<double, -1, 1>(lcm_sym20__);
+      stan::math::fill(phi_std_raw, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 2;
+      phi_std_raw = in__.vector(lcm_sym20__);
+      double sigma_phi;
+      sigma_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      validate_non_negative_index("phi", "N", N);
+      Eigen::Matrix<double, -1, 1> phi;
+      phi = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(phi, std::numeric_limits<double>::quiet_NaN());
+      
+      vars__.push_back(tau_phi);
+      if (logical_gte(lcm_sym20__, 1)) {
+        vars__.push_back(
+          rvalue(phi_std_raw, cons_list(index_uni(1), nil_index_list()),
+            "phi_std_raw"));
+        for (int sym1__ = 2; sym1__ <= lcm_sym20__; ++sym1__) {
+          vars__.push_back(phi_std_raw[(sym1__ - 1)]);}
+      } 
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      lcm_sym16__ = inv_sqrt(tau_phi);
+      sigma_phi = lcm_sym16__;
+      current_statement__ = 5;
+      assign(phi, cons_list(index_min_max(1, lcm_sym20__), nil_index_list()),
+        phi_std_raw, "assigning variable phi");
+      current_statement__ = 6;
+      assign(phi, cons_list(index_uni(N), nil_index_list()),
+        -sum(phi_std_raw), "assigning variable phi");
+      current_statement__ = 7;
+      assign(phi, nil_index_list(),
+        multiply(stan::model::deep_copy(phi), lcm_sym16__),
+        "assigning variable phi");
+      vars__.push_back(lcm_sym16__);
+      lcm_sym8__ = logical_gte(N, 1);
+      if (lcm_sym8__) {
+        vars__.push_back(
+          rvalue(phi, cons_list(index_uni(1), nil_index_list()), "phi"));
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          vars__.push_back(phi[(sym1__ - 1)]);}
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+      double beta0;
+      beta0 = std::numeric_limits<double>::quiet_NaN();
+      
+      double beta1;
+      beta1 = std::numeric_limits<double>::quiet_NaN();
+      
+      double tau_theta;
+      tau_theta = std::numeric_limits<double>::quiet_NaN();
+      
+      double sigma_theta;
+      sigma_theta = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 12;
+      validate_non_negative_index("theta", "N", N);
+      Eigen::Matrix<double, -1, 1> theta;
+      theta = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(theta, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 13;
+      validate_non_negative_index("theta_std", "N", N);
+      Eigen::Matrix<double, -1, 1> theta_std;
+      theta_std = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(theta_std, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 14;
+      validate_non_negative_index("x", "N", N);
+      Eigen::Matrix<double, -1, 1> x;
+      x = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(x, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 15;
+      validate_non_negative_index("y", "N", N);
+      std::vector<int> y;
+      y = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 16;
+      beta0 = normal_rng(0, 1, base_rng__);
+      current_statement__ = 17;
+      beta1 = normal_rng(0, 1, base_rng__);
+      current_statement__ = 20;
+      if (lcm_sym8__) {
+        current_statement__ = 18;
+        assign(theta_std, cons_list(index_uni(1), nil_index_list()),
+          normal_rng(0, 1, base_rng__), "assigning variable theta_std");
+        for (int i = 2; i <= N; ++i) {
+          current_statement__ = 18;
+          assign(theta_std, cons_list(index_uni(i), nil_index_list()),
+            normal_rng(0, 1, base_rng__), "assigning variable theta_std");}
+      } 
+      current_statement__ = 21;
+      tau_theta = gamma_rng(3.2761, 1.81, base_rng__);
+      lcm_sym17__ = inv_sqrt(tau_theta);
+      sigma_theta = lcm_sym17__;
+      assign(lcm_sym15__, nil_index_list(), multiply(theta_std, lcm_sym17__),
+        "assigning variable lcm_sym15__");
+      assign(theta, nil_index_list(), lcm_sym15__, "assigning variable theta");
+      current_statement__ = 25;
+      if (lcm_sym8__) {
+        current_statement__ = 22;
+        assign(x, cons_list(index_uni(1), nil_index_list()),
+          normal_rng(0, 1, base_rng__), "assigning variable x");
+        current_statement__ = 23;
+        assign(y, cons_list(index_uni(1), nil_index_list()),
+          poisson_log_rng(
+            ((stan::math::fma(beta1,
+                rvalue(x, cons_list(index_uni(1), nil_index_list()), "x"),
+                (rvalue(stan::math::log(E),
+                   cons_list(index_uni(1), nil_index_list()), "log(E)") +
+                  beta0)) +
+               rvalue(phi, cons_list(index_uni(1), nil_index_list()), "phi"))
+              +
+              rvalue(lcm_sym15__, cons_list(index_uni(1), nil_index_list()),
+                "lcm_sym15__")), base_rng__), "assigning variable y");
+        for (int i = 2; i <= N; ++i) {
+          current_statement__ = 22;
+          assign(x, cons_list(index_uni(i), nil_index_list()),
+            normal_rng(0, 1, base_rng__), "assigning variable x");
+          current_statement__ = 23;
+          assign(y, cons_list(index_uni(i), nil_index_list()),
+            poisson_log_rng(
+              ((stan::math::fma(beta1,
+                  rvalue(x, cons_list(index_uni(i), nil_index_list()), "x"),
+                  (rvalue(stan::math::log(E),
+                     cons_list(index_uni(i), nil_index_list()), "log(E)") +
+                    beta0)) +
+                 rvalue(phi, cons_list(index_uni(i), nil_index_list()),
+                   "phi")) +
+                rvalue(lcm_sym15__,
+                  cons_list(index_uni(i), nil_index_list()), "lcm_sym15__")),
+              base_rng__), "assigning variable y");}
+      } 
+      current_statement__ = 10;
+      current_statement__ = 10;
+      check_greater_or_equal(function__, "tau_theta", tau_theta, 0);
+      current_statement__ = 11;
+      current_statement__ = 11;
+      check_greater_or_equal(function__, "sigma_theta", lcm_sym17__, 0);
+      vars__.push_back(beta0);
+      vars__.push_back(beta1);
+      vars__.push_back(tau_theta);
+      vars__.push_back(lcm_sym17__);
+      if (lcm_sym8__) {
+        vars__.push_back(
+          rvalue(lcm_sym15__, cons_list(index_uni(1), nil_index_list()),
+            "lcm_sym15__"));
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          vars__.push_back(lcm_sym15__[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym8__) {
+        vars__.push_back(
+          rvalue(theta_std, cons_list(index_uni(1), nil_index_list()),
+            "theta_std"));
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          vars__.push_back(theta_std[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym8__) {
+        vars__.push_back(
+          rvalue(x, cons_list(index_uni(1), nil_index_list()), "x"));
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          vars__.push_back(x[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym8__) {
+        vars__.push_back(
+          rvalue(y, cons_list(index_uni(1), nil_index_list()), "y"));
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          vars__.push_back(y[(sym1__ - 1)]);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym7__;
+      double lcm_sym6__;
+      double lcm_sym5__;
+      double lcm_sym4__;
+      int lcm_sym3__;
+      int lcm_sym2__;
+      int lcm_sym1__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double tau_phi;
+      tau_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      tau_phi = context__.vals_r("tau_phi")[(1 - 1)];
+      current_statement__ = 1;
+      tau_phi = stan::math::lb_free(tau_phi, 0);
+      lcm_sym2__ = (N - 1);
+      validate_non_negative_index("phi_std_raw", "(N - 1)", lcm_sym2__);
+      Eigen::Matrix<double, -1, 1> phi_std_raw;
+      phi_std_raw = Eigen::Matrix<double, -1, 1>(lcm_sym2__);
+      stan::math::fill(phi_std_raw, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> phi_std_raw_flat__;
+        current_statement__ = 2;
+        assign(phi_std_raw_flat__, nil_index_list(),
+          context__.vals_r("phi_std_raw"),
+          "assigning variable phi_std_raw_flat__");
+        current_statement__ = 2;
+        pos__ = 1;
+        lcm_sym1__ = logical_gte(lcm_sym2__, 1);
+        if (lcm_sym1__) {
+          current_statement__ = 2;
+          assign(phi_std_raw, cons_list(index_uni(1), nil_index_list()),
+            rvalue(phi_std_raw_flat__,
+              cons_list(index_uni(1), nil_index_list()),
+              "phi_std_raw_flat__"), "assigning variable phi_std_raw");
+          current_statement__ = 2;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= lcm_sym2__; ++sym1__) {
+            current_statement__ = 2;
+            assign(phi_std_raw,
+              cons_list(index_uni(sym1__), nil_index_list()),
+              phi_std_raw_flat__[(pos__ - 1)],
+              "assigning variable phi_std_raw");
+            current_statement__ = 2;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      vars__.push_back(tau_phi);
+      if (lcm_sym1__) {
+        vars__.push_back(
+          rvalue(phi_std_raw, cons_list(index_uni(1), nil_index_list()),
+            "phi_std_raw"));
+        for (int sym1__ = 2; sym1__ <= lcm_sym2__; ++sym1__) {
+          vars__.push_back(phi_std_raw[(sym1__ - 1)]);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("tau_phi");
+    names__.push_back("phi_std_raw");
+    names__.push_back("sigma_phi");
+    names__.push_back("phi");
+    names__.push_back("beta0");
+    names__.push_back("beta1");
+    names__.push_back("tau_theta");
+    names__.push_back("sigma_theta");
+    names__.push_back("theta");
+    names__.push_back("theta_std");
+    names__.push_back("x");
+    names__.push_back("y");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back((N - 1));
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(N);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(N);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(N);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(N);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(N);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "tau_phi");
+    for (int sym50__ = 1; sym50__ <= (N - 1); ++sym50__) {
+      {
+        param_names__.push_back(std::string() + "phi_std_raw" + '.' + std::to_string(sym50__));
+      }}
+    if (emit_transformed_parameters__) {
+      param_names__.push_back(std::string() + "sigma_phi");
+      for (int sym50__ = 1; sym50__ <= N; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym50__));
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      param_names__.push_back(std::string() + "beta0");
+      param_names__.push_back(std::string() + "beta1");
+      param_names__.push_back(std::string() + "tau_theta");
+      param_names__.push_back(std::string() + "sigma_theta");
+      for (int sym50__ = 1; sym50__ <= N; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym50__));
+        }}
+      for (int sym50__ = 1; sym50__ <= N; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "theta_std" + '.' + std::to_string(sym50__));
+        }}
+      for (int sym50__ = 1; sym50__ <= N; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "x" + '.' + std::to_string(sym50__));
+        }}
+      for (int sym50__ = 1; sym50__ <= N; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "y" + '.' + std::to_string(sym50__));
+        }}
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "tau_phi");
+    for (int sym50__ = 1; sym50__ <= (N - 1); ++sym50__) {
+      {
+        param_names__.push_back(std::string() + "phi_std_raw" + '.' + std::to_string(sym50__));
+      }}
+    if (emit_transformed_parameters__) {
+      param_names__.push_back(std::string() + "sigma_phi");
+      for (int sym50__ = 1; sym50__ <= N; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym50__));
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      param_names__.push_back(std::string() + "beta0");
+      param_names__.push_back(std::string() + "beta1");
+      param_names__.push_back(std::string() + "tau_theta");
+      param_names__.push_back(std::string() + "sigma_theta");
+      for (int sym50__ = 1; sym50__ <= N; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym50__));
+        }}
+      for (int sym50__ = 1; sym50__ <= N; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "theta_std" + '.' + std::to_string(sym50__));
+        }}
+      for (int sym50__ = 1; sym50__ <= N; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "x" + '.' + std::to_string(sym50__));
+        }}
+      for (int sym50__ = 1; sym50__ <= N; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "y" + '.' + std::to_string(sym50__));
+        }}
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"tau_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi_std_raw\",\"type\":{\"name\":\"vector\",\"length\":" << (N - 1) << "},\"block\":\"parameters\"},{\"name\":\"sigma_phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"},{\"name\":\"beta0\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"beta1\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"tau_theta\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"sigma_theta\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"theta\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"generated_quantities\"},{\"name\":\"theta_std\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"generated_quantities\"},{\"name\":\"x\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"generated_quantities\"},{\"name\":\"y\",\"type\":{\"name\":\"array\",\"length\":" << N << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"tau_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi_std_raw\",\"type\":{\"name\":\"vector\",\"length\":" << (N - 1) << "},\"block\":\"parameters\"},{\"name\":\"sigma_phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"},{\"name\":\"beta0\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"beta1\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"tau_theta\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"sigma_theta\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"theta\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"generated_quantities\"},{\"name\":\"theta_std\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"generated_quantities\"},{\"name\":\"x\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"generated_quantities\"},{\"name\":\"y\",\"type\":{\"name\":\"array\",\"length\":" << N << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef expr_prop_fail4_model_namespace::expr_prop_fail4_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail5.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace expr_prop_fail5_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'expr-prop-fail5.stan', line 71, column 2 to column 33)",
+                                                      " (in 'expr-prop-fail5.stan', line 72, column 2 to column 31)",
+                                                      " (in 'expr-prop-fail5.stan', line 73, column 2 to column 23)",
+                                                      " (in 'expr-prop-fail5.stan', line 74, column 2 to column 30)",
+                                                      " (in 'expr-prop-fail5.stan', line 80, column 2 to column 51)",
+                                                      " (in 'expr-prop-fail5.stan', line 81, column 2 to column 49)",
+                                                      " (in 'expr-prop-fail5.stan', line 82, column 2 to column 49)",
+                                                      " (in 'expr-prop-fail5.stan', line 83, column 2 to column 10)",
+                                                      " (in 'expr-prop-fail5.stan', line 89, column 6 to column 20)",
+                                                      " (in 'expr-prop-fail5.stan', line 90, column 6 to column 18)",
+                                                      " (in 'expr-prop-fail5.stan', line 88, column 32 to line 91, column 5)",
+                                                      " (in 'expr-prop-fail5.stan', line 93, column 6 to column 45)",
+                                                      " (in 'expr-prop-fail5.stan', line 94, column 6 to column 23)",
+                                                      " (in 'expr-prop-fail5.stan', line 92, column 38 to line 95, column 5)",
+                                                      " (in 'expr-prop-fail5.stan', line 92, column 4 to line 95, column 5)",
+                                                      " (in 'expr-prop-fail5.stan', line 87, column 20 to line 96, column 3)",
+                                                      " (in 'expr-prop-fail5.stan', line 87, column 2 to line 96, column 3)",
+                                                      " (in 'expr-prop-fail5.stan', line 26, column 4 to column 34)",
+                                                      " (in 'expr-prop-fail5.stan', line 29, column 6 to column 32)",
+                                                      " (in 'expr-prop-fail5.stan', line 32, column 8 to column 37)",
+                                                      " (in 'expr-prop-fail5.stan', line 33, column 8 to column 32)",
+                                                      " (in 'expr-prop-fail5.stan', line 43, column 8 to line 44, column 83)",
+                                                      " (in 'expr-prop-fail5.stan', line 30, column 37 to line 45, column 7)",
+                                                      " (in 'expr-prop-fail5.stan', line 28, column 22 to line 46, column 5)",
+                                                      " (in 'expr-prop-fail5.stan', line 25, column 47 to line 48, column 3)",
+                                                      " (in 'expr-prop-fail5.stan', line 124, column 2 to column 23)",
+                                                      " (in 'expr-prop-fail5.stan', line 109, column 2 to column 29)",
+                                                      " (in 'expr-prop-fail5.stan', line 115, column 8 to column 37)",
+                                                      " (in 'expr-prop-fail5.stan', line 116, column 8 to column 41)",
+                                                      " (in 'expr-prop-fail5.stan', line 114, column 40 to line 117, column 7)",
+                                                      " (in 'expr-prop-fail5.stan', line 118, column 6 to column 37)",
+                                                      " (in 'expr-prop-fail5.stan', line 113, column 22 to line 119, column 5)",
+                                                      " (in 'expr-prop-fail5.stan', line 112, column 20 to line 120, column 3)",
+                                                      " (in 'expr-prop-fail5.stan', line 112, column 2 to line 120, column 3)",
+                                                      " (in 'expr-prop-fail5.stan', line 52, column 2 to column 20)",
+                                                      " (in 'expr-prop-fail5.stan', line 53, column 2 to column 27)",
+                                                      " (in 'expr-prop-fail5.stan', line 54, column 2 to column 44)",
+                                                      " (in 'expr-prop-fail5.stan', line 58, column 2 to column 38)",
+                                                      " (in 'expr-prop-fail5.stan', line 60, column 2 to column 45)",
+                                                      " (in 'expr-prop-fail5.stan', line 61, column 2 to column 44)",
+                                                      " (in 'expr-prop-fail5.stan', line 8, column 8 to column 17)",
+                                                      " (in 'expr-prop-fail5.stan', line 7, column 6 to line 8, column 17)",
+                                                      " (in 'expr-prop-fail5.stan', line 5, column 31 to line 10, column 3)",
+                                                      " (in 'expr-prop-fail5.stan', line 65, column 4 to column 35)",
+                                                      " (in 'expr-prop-fail5.stan', line 64, column 2 to line 65, column 35)",
+                                                      " (in 'expr-prop-fail5.stan', line 15, column 6 to column 32)",
+                                                      " (in 'expr-prop-fail5.stan', line 19, column 8 to column 17)",
+                                                      " (in 'expr-prop-fail5.stan', line 18, column 6 to line 19, column 17)",
+                                                      " (in 'expr-prop-fail5.stan', line 13, column 37 to line 20, column 5)",
+                                                      " (in 'expr-prop-fail5.stan', line 12, column 30 to line 22, column 3)",
+                                                      " (in 'expr-prop-fail5.stan', line 67, column 4 to column 33)",
+                                                      " (in 'expr-prop-fail5.stan', line 66, column 2 to line 67, column 33)",
+                                                      " (in 'expr-prop-fail5.stan', line 9, column 4 to column 13)",
+                                                      " (in 'expr-prop-fail5.stan', line 21, column 4 to column 13)",
+                                                      " (in 'expr-prop-fail5.stan', line 30, column 6 to line 45, column 7)",
+                                                      " (in 'expr-prop-fail5.stan', line 28, column 4 to line 46, column 5)",
+                                                      " (in 'expr-prop-fail5.stan', line 47, column 4 to column 15)"};
+
+
+int
+first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym29__;
+    int lcm_sym28__;
+    int lcm_sym27__;
+    int lcm_sym26__;
+    {
+      lcm_sym27__ = size(y_i);
+      if (logical_gte(lcm_sym27__, 1)) {
+        current_statement__ = 42;
+        if (rvalue(y_i, cons_list(index_uni(1), nil_index_list()), "y_i")) {
+          current_statement__ = 41;
+          return 1;
+        } 
+        for (int k = 2; k <= lcm_sym27__; ++k) {
+          current_statement__ = 42;
+          if (rvalue(y_i, cons_list(index_uni(k), nil_index_list()), "y_i")) {
+            current_statement__ = 41;
+            return k;
+          } }
+      } 
+      current_statement__ = 53;
+      return 0;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct first_capture_functor__ {
+int
+operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+{
+return first_capture(y_i, pstream__);
+}
+};
+
+int
+last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym35__;
+    int lcm_sym34__;
+    int lcm_sym33__;
+    int lcm_sym32__;
+    int lcm_sym31__;
+    int lcm_sym30__;
+    {
+      lcm_sym33__ = (size(y_i) - 1);
+      if (logical_gte(lcm_sym33__, 0)) {
+        int k;
+        k = std::numeric_limits<int>::min();
+        
+        lcm_sym32__ = (size(y_i) - 0);
+        current_statement__ = 48;
+        if (y_i[(lcm_sym32__ - 1)]) {
+          current_statement__ = 47;
+          return lcm_sym32__;
+        } 
+        for (int k_rev = 1; k_rev <= lcm_sym33__; ++k_rev) {
+          int k;
+          k = std::numeric_limits<int>::min();
+          
+          lcm_sym31__ = (size(y_i) - k_rev);
+          current_statement__ = 48;
+          if (y_i[(lcm_sym31__ - 1)]) {
+            current_statement__ = 47;
+            return lcm_sym31__;
+          } }
+      } 
+      current_statement__ = 54;
+      return 0;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct last_capture_functor__ {
+int
+operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+{
+return last_capture(y_i, pstream__);
+}
+};
+
+template <typename T2__, typename T3__>
+Eigen::Matrix<stan::promote_args_t<T2__,
+T3__>, -1, -1>
+prob_uncaptured(const int& nind, const int& n_occasions,
+                const Eigen::Matrix<T2__, -1, -1>& p,
+                const Eigen::Matrix<T3__, -1, -1>& phi,
+                std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<T2__, T3__>;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    double lcm_sym45__;
+    double lcm_sym44__;
+    double lcm_sym43__;
+    double lcm_sym42__;
+    int lcm_sym41__;
+    int lcm_sym40__;
+    int lcm_sym39__;
+    int lcm_sym38__;
+    int lcm_sym37__;
+    int lcm_sym36__;
+    {
+      current_statement__ = 18;
+      validate_non_negative_index("chi", "nind", nind);
+      current_statement__ = 18;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      current_statement__ = 56;
+      if (logical_gte(nind, 1)) {
+        current_statement__ = 19;
+        assign(chi,
+          cons_list(index_uni(1),
+            cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+          "assigning variable chi");
+        lcm_sym39__ = (n_occasions - 1);
+        lcm_sym37__ = logical_gte(lcm_sym39__, 1);
+        if (lcm_sym37__) {
+          int t_curr;
+          t_curr = std::numeric_limits<int>::min();
+          
+          int t_next;
+          t_next = std::numeric_limits<int>::min();
+          
+          lcm_sym41__ = (lcm_sym39__ + 1);
+          current_statement__ = 22;
+          assign(chi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym39__), nil_index_list())),
+            stan::math::fma(
+              (rvalue(phi,
+                 cons_list(index_uni(1),
+                   cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                 "phi") *
+                (1 -
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((lcm_sym41__ - 1)),
+                        nil_index_list())), "p"))),
+              rvalue(chi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(lcm_sym41__), nil_index_list())),
+                "chi"),
+              (1 -
+                rvalue(phi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                  "phi"))), "assigning variable chi");
+          for (int t = 2; t <= lcm_sym39__; ++t) {
+            int t_curr;
+            t_curr = std::numeric_limits<int>::min();
+            
+            lcm_sym38__ = (n_occasions - t);
+            int t_next;
+            t_next = std::numeric_limits<int>::min();
+            
+            lcm_sym40__ = (lcm_sym38__ + 1);
+            current_statement__ = 22;
+            assign(chi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(lcm_sym38__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(1),
+                     cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((lcm_sym40__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(chi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym40__), nil_index_list())),
+                  "chi"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                    "phi"))), "assigning variable chi");}
+        } 
+        for (int i = 2; i <= nind; ++i) {
+          current_statement__ = 19;
+          assign(chi,
+            cons_list(index_uni(i),
+              cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+            "assigning variable chi");
+          current_statement__ = 55;
+          if (lcm_sym37__) {
+            int t_curr;
+            t_curr = std::numeric_limits<int>::min();
+            
+            int t_next;
+            t_next = std::numeric_limits<int>::min();
+            
+            lcm_sym41__ = (lcm_sym39__ + 1);
+            current_statement__ = 22;
+            assign(chi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym39__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(i),
+                     cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((lcm_sym41__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(chi,
+                  cons_list(index_uni(i),
+                    cons_list(index_uni(lcm_sym41__), nil_index_list())),
+                  "chi"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                    "phi"))), "assigning variable chi");
+            for (int t = 2; t <= lcm_sym39__; ++t) {
+              int t_curr;
+              t_curr = std::numeric_limits<int>::min();
+              
+              lcm_sym38__ = (n_occasions - t);
+              int t_next;
+              t_next = std::numeric_limits<int>::min();
+              
+              lcm_sym40__ = (lcm_sym38__ + 1);
+              current_statement__ = 22;
+              assign(chi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(i),
+                       cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((lcm_sym40__ - 1)),
+                            nil_index_list())), "p"))),
+                  rvalue(chi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym40__), nil_index_list())),
+                    "chi"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                      "phi"))), "assigning variable chi");}
+          } }
+      } 
+      current_statement__ = 57;
+      return chi;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct prob_uncaptured_functor__ {
+template <typename T2__, typename T3__>
+Eigen::Matrix<stan::promote_args_t<T2__,
+T3__>, -1, -1>
+operator()(const int& nind, const int& n_occasions,
+           const Eigen::Matrix<T2__, -1, -1>& p,
+           const Eigen::Matrix<T3__, -1, -1>& phi, std::ostream* pstream__)  const 
+{
+return prob_uncaptured(nind, n_occasions, p, phi, pstream__);
+}
+};
+
+class expr_prop_fail5_model : public model_base_crtp<expr_prop_fail5_model> {
+
+ private:
+  int lcm_sym154__;
+  int lcm_sym153__;
+  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 lcm_sym142__;
+  int lcm_sym141__;
+  int lcm_sym140__;
+  int lcm_sym139__;
+  int lcm_sym138__;
+  int lcm_sym137__;
+  int lcm_sym136__;
+  int lcm_sym135__;
+  int lcm_sym134__;
+  int lcm_sym133__;
+  int lcm_sym132__;
+  int lcm_sym131__;
+  int pos__;
+  int nind;
+  int n_occasions;
+  std::vector<std::vector<int>> y;
+  int n_occ_minus_1;
+  std::vector<int> first;
+  std::vector<int> last;
+ 
+ public:
+  ~expr_prop_fail5_model() { }
+  
+  std::string model_name() const { return "expr_prop_fail5_model"; }
+  
+  expr_prop_fail5_model(stan::io::var_context& context__,
+                        unsigned int random_seed__ = 0,
+                        std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "expr_prop_fail5_model_namespace::expr_prop_fail5_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","nind","int",
+          context__.to_vec());
+      nind = std::numeric_limits<int>::min();
+      
+      current_statement__ = 35;
+      nind = context__.vals_i("nind")[(1 - 1)];
+      context__.validate_dims("data initialization","n_occasions","int",
+          context__.to_vec());
+      n_occasions = std::numeric_limits<int>::min();
+      
+      current_statement__ = 36;
+      n_occasions = context__.vals_i("n_occasions")[(1 - 1)];
+      current_statement__ = 37;
+      validate_non_negative_index("y", "nind", nind);
+      current_statement__ = 37;
+      validate_non_negative_index("y", "n_occasions", n_occasions);
+      context__.validate_dims("data initialization","y","int",
+          context__.to_vec(nind, n_occasions));
+      y = std::vector<std::vector<int>>(nind, std::vector<int>(n_occasions, std::numeric_limits<int>::min()));
+      
+      {
+        std::vector<int> y_flat__;
+        current_statement__ = 37;
+        assign(y_flat__, nil_index_list(), context__.vals_i("y"),
+          "assigning variable y_flat__");
+        current_statement__ = 37;
+        pos__ = 1;
+        lcm_sym131__ = logical_gte(n_occasions, 1);
+        if (lcm_sym131__) {
+          {
+            lcm_sym132__ = logical_gte(nind, 1);
+            if (lcm_sym132__) {
+              current_statement__ = 37;
+              assign(y,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(1), nil_index_list())),
+                rvalue(y_flat__, cons_list(index_uni(1), nil_index_list()),
+                  "y_flat__"), "assigning variable y");
+              current_statement__ = 37;
+              pos__ = 2;
+              for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+                current_statement__ = 37;
+                assign(y,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(1), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 37;
+                pos__ = (pos__ + 1);}
+            } 
+            for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+              current_statement__ = 37;
+              if (lcm_sym132__) {
+                current_statement__ = 37;
+                assign(y,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 37;
+                pos__ = (pos__ + 1);
+                for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+                  current_statement__ = 37;
+                  assign(y,
+                    cons_list(index_uni(sym2__),
+                      cons_list(index_uni(sym1__), nil_index_list())),
+                    y_flat__[(pos__ - 1)], "assigning variable y");
+                  current_statement__ = 37;
+                  pos__ = (pos__ + 1);}
+              } }
+          }
+        } else {
+          lcm_sym132__ = logical_gte(nind, 1);
+        }
+      }
+      n_occ_minus_1 = std::numeric_limits<int>::min();
+      
+      current_statement__ = 38;
+      n_occ_minus_1 = (n_occasions - 1);
+      current_statement__ = 39;
+      validate_non_negative_index("first", "nind", nind);
+      first = std::vector<int>(nind, std::numeric_limits<int>::min());
+      
+      current_statement__ = 40;
+      validate_non_negative_index("last", "nind", nind);
+      last = std::vector<int>(nind, std::numeric_limits<int>::min());
+      
+      current_statement__ = 45;
+      if (lcm_sym132__) {
+        int inline_sym17__;
+        int inline_sym19__;
+        inline_sym19__ = std::numeric_limits<int>::min();
+        
+        inline_sym19__ = 0;
+        for (int inline_sym20__ = 1; inline_sym20__ <= 1; ++inline_sym20__) {
+          lcm_sym140__ = size(
+                           rvalue(y,
+                             cons_list(index_uni(1), nil_index_list()), "y"));
+          for (int inline_sym18__ = 1; inline_sym18__ <= lcm_sym140__;
+               ++inline_sym18__) {
+            current_statement__ = 42;
+            if (rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")[
+                (inline_sym18__ - 1)]) {
+              inline_sym19__ = 1;
+              inline_sym17__ = inline_sym18__;
+              break;
+            } }
+          if (inline_sym19__) {
+            break;
+          } 
+          inline_sym19__ = 1;
+          inline_sym17__ = 0;
+          break;}
+        assign(first, cons_list(index_uni(1), nil_index_list()),
+          inline_sym17__, "assigning variable first");
+        for (int i = 2; i <= nind; ++i) {
+          int inline_sym17__;
+          int inline_sym19__;
+          inline_sym19__ = std::numeric_limits<int>::min();
+          
+          inline_sym19__ = 0;
+          for (int inline_sym20__ = 1; inline_sym20__ <= 1; ++inline_sym20__) {
+            lcm_sym139__ = size(
+                             rvalue(y,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "y"));
+            for (int inline_sym18__ = 1; inline_sym18__ <= lcm_sym139__;
+                 ++inline_sym18__) {
+              current_statement__ = 42;
+              if (rvalue(y, cons_list(index_uni(i), nil_index_list()), "y")[
+                  (inline_sym18__ - 1)]) {
+                inline_sym19__ = 1;
+                inline_sym17__ = inline_sym18__;
+                break;
+              } }
+            if (inline_sym19__) {
+              break;
+            } 
+            inline_sym19__ = 1;
+            inline_sym17__ = 0;
+            break;}
+          assign(first, cons_list(index_uni(i), nil_index_list()),
+            inline_sym17__, "assigning variable first");}
+      } 
+      current_statement__ = 52;
+      if (lcm_sym132__) {
+        int inline_sym21__;
+        int inline_sym24__;
+        inline_sym24__ = std::numeric_limits<int>::min();
+        
+        inline_sym24__ = 0;
+        for (int inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) {
+          lcm_sym140__ = size(
+                           rvalue(y,
+                             cons_list(index_uni(1), nil_index_list()), "y"));
+          lcm_sym137__ = (lcm_sym140__ - 1);
+          for (int inline_sym23__ = 0; inline_sym23__ <= lcm_sym137__;
+               ++inline_sym23__) {
+            int inline_sym22__;
+            inline_sym22__ = std::numeric_limits<int>::min();
+            
+            lcm_sym136__ = (lcm_sym140__ - inline_sym23__);
+            inline_sym22__ = lcm_sym136__;
+            current_statement__ = 48;
+            if (rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")[
+                (lcm_sym136__ - 1)]) {
+              inline_sym24__ = 1;
+              inline_sym21__ = lcm_sym136__;
+              break;
+            } }
+          if (inline_sym24__) {
+            break;
+          } 
+          inline_sym24__ = 1;
+          inline_sym21__ = 0;
+          break;}
+        assign(last, cons_list(index_uni(1), nil_index_list()),
+          inline_sym21__, "assigning variable last");
+        for (int i = 2; i <= nind; ++i) {
+          int inline_sym21__;
+          int inline_sym24__;
+          inline_sym24__ = std::numeric_limits<int>::min();
+          
+          inline_sym24__ = 0;
+          for (int inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) {
+            lcm_sym139__ = size(
+                             rvalue(y,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "y"));
+            lcm_sym135__ = (lcm_sym139__ - 1);
+            for (int inline_sym23__ = 0; inline_sym23__ <= lcm_sym135__;
+                 ++inline_sym23__) {
+              int inline_sym22__;
+              inline_sym22__ = std::numeric_limits<int>::min();
+              
+              lcm_sym134__ = (lcm_sym139__ - inline_sym23__);
+              inline_sym22__ = lcm_sym134__;
+              current_statement__ = 48;
+              if (rvalue(y, cons_list(index_uni(i), nil_index_list()), "y")[
+                  (lcm_sym134__ - 1)]) {
+                inline_sym24__ = 1;
+                inline_sym21__ = lcm_sym134__;
+                break;
+              } }
+            if (inline_sym24__) {
+              break;
+            } 
+            inline_sym24__ = 1;
+            inline_sym21__ = 0;
+            break;}
+          assign(last, cons_list(index_uni(i), nil_index_list()),
+            inline_sym21__, "assigning variable last");}
+      } 
+      current_statement__ = 35;
+      current_statement__ = 35;
+      check_greater_or_equal(function__, "nind", nind, 0);
+      current_statement__ = 36;
+      current_statement__ = 36;
+      check_greater_or_equal(function__, "n_occasions", n_occasions, 2);
+      current_statement__ = 37;
+      if (lcm_sym132__) {
+        current_statement__ = 37;
+        if (lcm_sym131__) {
+          current_statement__ = 37;
+          current_statement__ = 37;
+          check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                 rvalue(y,
+                                   cons_list(index_uni(1),
+                                     cons_list(index_uni(1),
+                                       nil_index_list())), "y"), 0);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 37;
+            current_statement__ = 37;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(1),
+                                       cons_list(index_uni(sym2__),
+                                         nil_index_list())), "y"), 0);}
+        } 
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 37;
+          if (lcm_sym131__) {
+            current_statement__ = 37;
+            current_statement__ = 37;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(sym1__),
+                                       cons_list(index_uni(1),
+                                         nil_index_list())), "y"), 0);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 37;
+              current_statement__ = 37;
+              check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                     y[(sym1__ - 1)][(sym2__ - 1)], 0);}
+          } }
+      } 
+      current_statement__ = 37;
+      if (lcm_sym132__) {
+        current_statement__ = 37;
+        if (lcm_sym131__) {
+          current_statement__ = 37;
+          current_statement__ = 37;
+          check_less_or_equal(function__, "y[sym1__, sym2__]",
+                              rvalue(y,
+                                cons_list(index_uni(1),
+                                  cons_list(index_uni(1), nil_index_list())),
+                                "y"), 1);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 37;
+            current_statement__ = 37;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(1),
+                                    cons_list(index_uni(sym2__),
+                                      nil_index_list())), "y"), 1);}
+        } 
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 37;
+          if (lcm_sym131__) {
+            current_statement__ = 37;
+            current_statement__ = 37;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(sym1__),
+                                    cons_list(index_uni(1), nil_index_list())),
+                                  "y"), 1);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 37;
+              current_statement__ = 37;
+              check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                  y[(sym1__ - 1)][(sym2__ - 1)], 1);}
+          } }
+      } 
+      current_statement__ = 39;
+      if (lcm_sym132__) {
+        current_statement__ = 39;
+        current_statement__ = 39;
+        check_greater_or_equal(function__, "first[sym1__]",
+                               rvalue(first,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "first"), 0);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 39;
+          current_statement__ = 39;
+          check_greater_or_equal(function__, "first[sym1__]",
+                                 first[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 39;
+      if (lcm_sym132__) {
+        current_statement__ = 39;
+        current_statement__ = 39;
+        check_less_or_equal(function__, "first[sym1__]",
+                            rvalue(first,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "first"), n_occasions);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 39;
+          current_statement__ = 39;
+          check_less_or_equal(function__, "first[sym1__]",
+                              first[(sym1__ - 1)], n_occasions);}
+      } 
+      current_statement__ = 40;
+      if (lcm_sym132__) {
+        current_statement__ = 40;
+        current_statement__ = 40;
+        check_greater_or_equal(function__, "last[sym1__]",
+                               rvalue(last,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "last"), 0);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 40;
+          current_statement__ = 40;
+          check_greater_or_equal(function__, "last[sym1__]",
+                                 last[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 40;
+      if (lcm_sym132__) {
+        current_statement__ = 40;
+        current_statement__ = 40;
+        check_less_or_equal(function__, "last[sym1__]",
+                            rvalue(last,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "last"), n_occasions);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 40;
+          current_statement__ = 40;
+          check_less_or_equal(function__, "last[sym1__]", last[(sym1__ - 1)],
+                              n_occasions);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      current_statement__ = 3;
+      validate_non_negative_index("epsilon", "nind", nind);
+      num_params_r__ += nind;
+      num_params_r__ += 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "expr_prop_fail5_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      int lcm_sym130__;
+      int lcm_sym129__;
+      int lcm_sym128__;
+      int lcm_sym127__;
+      double lcm_sym126__;
+      local_scalar_t__ lcm_sym125__;
+      local_scalar_t__ lcm_sym124__;
+      local_scalar_t__ lcm_sym123__;
+      double lcm_sym122__;
+      double lcm_sym121__;
+      double lcm_sym120__;
+      double lcm_sym119__;
+      double lcm_sym118__;
+      double lcm_sym117__;
+      double lcm_sym116__;
+      double lcm_sym115__;
+      double lcm_sym114__;
+      double lcm_sym113__;
+      double lcm_sym112__;
+      double lcm_sym111__;
+      int lcm_sym110__;
+      int lcm_sym109__;
+      int lcm_sym108__;
+      int lcm_sym107__;
+      int lcm_sym106__;
+      int lcm_sym105__;
+      int lcm_sym104__;
+      int lcm_sym103__;
+      int lcm_sym102__;
+      int lcm_sym101__;
+      int lcm_sym100__;
+      int lcm_sym99__;
+      int lcm_sym98__;
+      int lcm_sym97__;
+      int lcm_sym96__;
+      int lcm_sym95__;
+      int lcm_sym94__;
+      int lcm_sym93__;
+      int lcm_sym92__;
+      int lcm_sym91__;
+      local_scalar_t__ mean_phi;
+      mean_phi = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      mean_phi = in__.scalar();
+      current_statement__ = 1;
+      if (jacobian__) {
+        current_statement__ = 1;
+        mean_phi = stan::math::lub_constrain(mean_phi, 0, 1, lp__);
+      } else {
+        current_statement__ = 1;
+        mean_phi = stan::math::lub_constrain(mean_phi, 0, 1);
+      }
+      local_scalar_t__ mean_p;
+      mean_p = DUMMY_VAR__;
+      
+      current_statement__ = 2;
+      mean_p = in__.scalar();
+      current_statement__ = 2;
+      if (jacobian__) {
+        current_statement__ = 2;
+        mean_p = stan::math::lub_constrain(mean_p, 0, 1, lp__);
+      } else {
+        current_statement__ = 2;
+        mean_p = stan::math::lub_constrain(mean_p, 0, 1);
+      }
+      current_statement__ = 3;
+      validate_non_negative_index("epsilon", "nind", nind);
+      Eigen::Matrix<local_scalar_t__, -1, 1> epsilon;
+      epsilon = Eigen::Matrix<local_scalar_t__, -1, 1>(nind);
+      stan::math::fill(epsilon, DUMMY_VAR__);
+      
+      current_statement__ = 3;
+      epsilon = in__.vector(nind);
+      local_scalar_t__ sigma;
+      sigma = DUMMY_VAR__;
+      
+      current_statement__ = 4;
+      sigma = in__.scalar();
+      current_statement__ = 4;
+      if (jacobian__) {
+        current_statement__ = 4;
+        sigma = stan::math::lub_constrain(sigma, 0, 5, lp__);
+      } else {
+        current_statement__ = 4;
+        sigma = stan::math::lub_constrain(sigma, 0, 5);
+      }
+      current_statement__ = 5;
+      validate_non_negative_index("phi", "nind", nind);
+      lcm_sym102__ = (n_occasions - 1);
+      validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym102__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> phi;
+      phi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, lcm_sym102__);
+      stan::math::fill(phi, DUMMY_VAR__);
+      
+      current_statement__ = 6;
+      validate_non_negative_index("p", "nind", nind);
+      current_statement__ = 6;
+      validate_non_negative_index("p", "n_occ_minus_1", lcm_sym102__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> p;
+      p = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, lcm_sym102__);
+      stan::math::fill(p, DUMMY_VAR__);
+      
+      current_statement__ = 7;
+      validate_non_negative_index("chi", "nind", nind);
+      current_statement__ = 7;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      local_scalar_t__ mu;
+      mu = DUMMY_VAR__;
+      
+      lcm_sym125__ = logit(mean_phi);
+      mu = lcm_sym125__;
+      lcm_sym91__ = logical_gte(nind, 1);
+      if (lcm_sym91__) {
+        lcm_sym128__ = rvalue(first,
+                         cons_list(index_uni(1), nil_index_list()), "first");
+        lcm_sym104__ = (lcm_sym128__ - 1);
+        if (logical_gte(lcm_sym104__, 1)) {
+          current_statement__ = 9;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable phi");
+          current_statement__ = 10;
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable p");
+          for (int t = 2; t <= lcm_sym104__; ++t) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 10;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable p");}
+        } 
+        current_statement__ = 15;
+        if (logical_gte(lcm_sym102__, lcm_sym128__)) {
+          lcm_sym124__ = inv_logit(
+                           (lcm_sym125__ +
+                             rvalue(epsilon,
+                               cons_list(index_uni(1), nil_index_list()),
+                               "epsilon")));
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym128__), nil_index_list())),
+            lcm_sym124__, "assigning variable phi");
+          lcm_sym110__ = (lcm_sym128__ + 1);
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym128__), nil_index_list())), mean_p,
+            "assigning variable p");
+          for (int t = lcm_sym110__; t <= lcm_sym102__; ++t) {
+            current_statement__ = 12;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), lcm_sym124__,
+              "assigning variable phi");
+            current_statement__ = 13;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), mean_p,
+              "assigning variable p");}
+        } 
+        for (int i = 2; i <= nind; ++i) {
+          lcm_sym127__ = rvalue(first,
+                           cons_list(index_uni(i), nil_index_list()),
+                           "first");
+          lcm_sym103__ = (lcm_sym127__ - 1);
+          if (logical_gte(lcm_sym103__, 1)) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 10;
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable p");
+            for (int t = 2; t <= lcm_sym103__; ++t) {
+              current_statement__ = 9;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable phi");
+              current_statement__ = 10;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable p");}
+          } 
+          current_statement__ = 15;
+          if (logical_gte(lcm_sym102__, lcm_sym127__)) {
+            lcm_sym123__ = inv_logit(
+                             (lcm_sym125__ +
+                               rvalue(epsilon,
+                                 cons_list(index_uni(i), nil_index_list()),
+                                 "epsilon")));
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym127__), nil_index_list())),
+              lcm_sym123__, "assigning variable phi");
+            lcm_sym109__ = (lcm_sym127__ + 1);
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym127__), nil_index_list())),
+              mean_p, "assigning variable p");
+            for (int t = lcm_sym109__; t <= lcm_sym102__; ++t) {
+              current_statement__ = 12;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), lcm_sym123__,
+                "assigning variable phi");
+              current_statement__ = 13;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), mean_p,
+                "assigning variable p");}
+          } }
+      } 
+      Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym9__;
+      int inline_sym15__;
+      inline_sym15__ = std::numeric_limits<int>::min();
+      
+      inline_sym15__ = 0;
+      for (int inline_sym16__ = 1; inline_sym16__ <= 1; ++inline_sym16__) {
+        current_statement__ = 18;
+        validate_non_negative_index("chi", "nind", nind);
+        current_statement__ = 18;
+        validate_non_negative_index("chi", "n_occasions", n_occasions);
+        Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym10__;
+        inline_sym10__ = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+        stan::math::fill(inline_sym10__, DUMMY_VAR__);
+        
+        for (int inline_sym14__ = 1; inline_sym14__ <= nind; ++inline_sym14__) {
+          current_statement__ = 19;
+          assign(inline_sym10__,
+            cons_list(index_uni(inline_sym14__),
+              cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+            "assigning variable inline_sym10__");
+          if (logical_gte(lcm_sym102__, 1)) {
+            int inline_sym11__;
+            inline_sym11__ = std::numeric_limits<int>::min();
+            
+            int inline_sym12__;
+            inline_sym12__ = std::numeric_limits<int>::min();
+            
+            lcm_sym106__ = (lcm_sym102__ + 1);
+            current_statement__ = 22;
+            assign(inline_sym10__,
+              cons_list(index_uni(inline_sym14__),
+                cons_list(index_uni(lcm_sym102__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(inline_sym14__),
+                     cons_list(index_uni(lcm_sym102__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(inline_sym14__),
+                        cons_list(index_uni((lcm_sym106__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(inline_sym10__,
+                  cons_list(index_uni(inline_sym14__),
+                    cons_list(index_uni(lcm_sym106__), nil_index_list())),
+                  "inline_sym10__"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(inline_sym14__),
+                      cons_list(index_uni(lcm_sym102__), nil_index_list())),
+                    "phi"))), "assigning variable inline_sym10__");
+            for (int inline_sym13__ = 2; inline_sym13__ <= lcm_sym102__;
+                 ++inline_sym13__) {
+              int inline_sym11__;
+              inline_sym11__ = std::numeric_limits<int>::min();
+              
+              int inline_sym12__;
+              inline_sym12__ = std::numeric_limits<int>::min();
+              
+              lcm_sym101__ = (n_occasions - inline_sym13__);
+              lcm_sym105__ = (lcm_sym101__ + 1);
+              current_statement__ = 22;
+              assign(inline_sym10__,
+                cons_list(index_uni(inline_sym14__),
+                  cons_list(index_uni(lcm_sym101__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(inline_sym14__),
+                       cons_list(index_uni(lcm_sym101__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(inline_sym14__),
+                          cons_list(index_uni((lcm_sym105__ - 1)),
+                            nil_index_list())), "p"))),
+                  rvalue(inline_sym10__,
+                    cons_list(index_uni(inline_sym14__),
+                      cons_list(index_uni(lcm_sym105__), nil_index_list())),
+                    "inline_sym10__"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(inline_sym14__),
+                        cons_list(index_uni(lcm_sym101__), nil_index_list())),
+                      "phi"))), "assigning variable inline_sym10__");}
+          } 
+          if (inline_sym15__) {
+            break;
+          } }
+        if (inline_sym15__) {
+          break;
+        } 
+        inline_sym15__ = 1;
+        assign(inline_sym9__, nil_index_list(), inline_sym10__,
+          "assigning variable inline_sym9__");
+        break;}
+      assign(chi, nil_index_list(), inline_sym9__, "assigning variable chi");
+      current_statement__ = 5;
+      current_statement__ = 5;
+      check_greater_or_equal(function__, "phi", phi, 0);
+      current_statement__ = 5;
+      current_statement__ = 5;
+      check_less_or_equal(function__, "phi", phi, 1);
+      current_statement__ = 6;
+      current_statement__ = 6;
+      check_greater_or_equal(function__, "p", p, 0);
+      current_statement__ = 6;
+      current_statement__ = 6;
+      check_less_or_equal(function__, "p", p, 1);
+      current_statement__ = 7;
+      current_statement__ = 7;
+      check_greater_or_equal(function__, "chi", inline_sym9__, 0);
+      current_statement__ = 7;
+      current_statement__ = 7;
+      check_less_or_equal(function__, "chi", inline_sym9__, 1);
+      {
+        current_statement__ = 27;
+        lp_accum__.add(normal_log<propto__>(epsilon, 0, sigma));
+        current_statement__ = 34;
+        if (lcm_sym91__) {
+          lcm_sym128__ = rvalue(first,
+                           cons_list(index_uni(1), nil_index_list()),
+                           "first");
+          if (logical_gt(lcm_sym128__, 0)) {
+            lcm_sym130__ = rvalue(last,
+                             cons_list(index_uni(1), nil_index_list()),
+                             "last");
+            lcm_sym110__ = (lcm_sym128__ + 1);
+            if (logical_gte(lcm_sym130__, lcm_sym110__)) {
+              current_statement__ = 28;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(phi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((lcm_sym110__ - 1)),
+                        nil_index_list())), "phi")));
+              lcm_sym108__ = (lcm_sym110__ + 1);
+              lp_accum__.add(
+                bernoulli_log<propto__>(
+                  rvalue(y,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym110__), nil_index_list())),
+                    "y"),
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((lcm_sym110__ - 1)),
+                        nil_index_list())), "p")));
+              for (int t = lcm_sym108__; t <= lcm_sym130__; ++t) {
+                current_statement__ = 28;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(phi,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((t - 1)), nil_index_list())),
+                      "phi")));
+                current_statement__ = 29;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(
+                    rvalue(y,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(t), nil_index_list())), "y"),
+                    rvalue(p,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((t - 1)), nil_index_list())),
+                      "p")));}
+            } 
+            current_statement__ = 31;
+            lp_accum__.add(
+              bernoulli_log<propto__>(1,
+                rvalue(inline_sym9__,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym130__), nil_index_list())),
+                  "inline_sym9__")));
+          } 
+          for (int i = 2; i <= nind; ++i) {
+            lcm_sym127__ = rvalue(first,
+                             cons_list(index_uni(i), nil_index_list()),
+                             "first");
+            if (logical_gt(lcm_sym127__, 0)) {
+              lcm_sym129__ = rvalue(last,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "last");
+              lcm_sym109__ = (lcm_sym127__ + 1);
+              if (logical_gte(lcm_sym129__, lcm_sym109__)) {
+                current_statement__ = 28;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(phi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((lcm_sym109__ - 1)),
+                          nil_index_list())), "phi")));
+                lcm_sym107__ = (lcm_sym109__ + 1);
+                lp_accum__.add(
+                  bernoulli_log<propto__>(
+                    rvalue(y,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym109__), nil_index_list())),
+                      "y"),
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((lcm_sym109__ - 1)),
+                          nil_index_list())), "p")));
+                for (int t = lcm_sym107__; t <= lcm_sym129__; ++t) {
+                  current_statement__ = 28;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(1,
+                      rvalue(phi,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((t - 1)), nil_index_list())),
+                        "phi")));
+                  current_statement__ = 29;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(
+                      rvalue(y,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni(t), nil_index_list())), "y"),
+                      rvalue(p,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((t - 1)), nil_index_list())),
+                        "p")));}
+              } 
+              current_statement__ = 31;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(inline_sym9__,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym129__), nil_index_list())),
+                    "inline_sym9__")));
+            } }
+        } 
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "expr_prop_fail5_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym90__;
+      double lcm_sym89__;
+      double lcm_sym88__;
+      double lcm_sym87__;
+      double lcm_sym86__;
+      double lcm_sym85__;
+      double lcm_sym84__;
+      double lcm_sym83__;
+      double lcm_sym82__;
+      double lcm_sym81__;
+      double lcm_sym80__;
+      double lcm_sym79__;
+      int lcm_sym78__;
+      int lcm_sym77__;
+      double lcm_sym76__;
+      double lcm_sym75__;
+      double lcm_sym74__;
+      double lcm_sym73__;
+      local_scalar_t__ lcm_sym72__;
+      local_scalar_t__ lcm_sym71__;
+      double lcm_sym70__;
+      double lcm_sym69__;
+      int lcm_sym68__;
+      int lcm_sym67__;
+      int lcm_sym66__;
+      int lcm_sym65__;
+      int lcm_sym64__;
+      int lcm_sym63__;
+      int lcm_sym62__;
+      int lcm_sym61__;
+      int lcm_sym60__;
+      int lcm_sym59__;
+      int lcm_sym58__;
+      int lcm_sym57__;
+      int lcm_sym56__;
+      int lcm_sym55__;
+      int lcm_sym54__;
+      int lcm_sym53__;
+      int lcm_sym52__;
+      double mean_phi;
+      mean_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mean_phi = in__.scalar();
+      current_statement__ = 1;
+      mean_phi = stan::math::lub_constrain(mean_phi, 0, 1);
+      double mean_p;
+      mean_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      mean_p = in__.scalar();
+      current_statement__ = 2;
+      mean_p = stan::math::lub_constrain(mean_p, 0, 1);
+      current_statement__ = 3;
+      validate_non_negative_index("epsilon", "nind", nind);
+      Eigen::Matrix<double, -1, 1> epsilon;
+      epsilon = Eigen::Matrix<double, -1, 1>(nind);
+      stan::math::fill(epsilon, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 3;
+      epsilon = in__.vector(nind);
+      double sigma;
+      sigma = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      sigma = in__.scalar();
+      current_statement__ = 4;
+      sigma = stan::math::lub_constrain(sigma, 0, 5);
+      current_statement__ = 5;
+      validate_non_negative_index("phi", "nind", nind);
+      lcm_sym60__ = (n_occasions - 1);
+      validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym60__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> phi;
+      phi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, lcm_sym60__);
+      stan::math::fill(phi, DUMMY_VAR__);
+      
+      current_statement__ = 6;
+      validate_non_negative_index("p", "nind", nind);
+      current_statement__ = 6;
+      validate_non_negative_index("p", "n_occ_minus_1", lcm_sym60__);
+      Eigen::Matrix<double, -1, -1> p;
+      p = Eigen::Matrix<double, -1, -1>(nind, lcm_sym60__);
+      stan::math::fill(p, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 7;
+      validate_non_negative_index("chi", "nind", nind);
+      current_statement__ = 7;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      double mu;
+      mu = std::numeric_limits<double>::quiet_NaN();
+      
+      vars__.push_back(mean_phi);
+      vars__.push_back(mean_p);
+      lcm_sym53__ = logical_gte(nind, 1);
+      if (lcm_sym53__) {
+        vars__.push_back(
+          rvalue(epsilon, cons_list(index_uni(1), nil_index_list()),
+            "epsilon"));
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          vars__.push_back(epsilon[(sym1__ - 1)]);}
+      } 
+      vars__.push_back(sigma);
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      lcm_sym73__ = logit(mean_phi);
+      mu = lcm_sym73__;
+      current_statement__ = 17;
+      if (lcm_sym53__) {
+        lcm_sym78__ = rvalue(first,
+                        cons_list(index_uni(1), nil_index_list()), "first");
+        lcm_sym62__ = (lcm_sym78__ - 1);
+        if (logical_gte(lcm_sym62__, 1)) {
+          current_statement__ = 9;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable phi");
+          current_statement__ = 10;
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable p");
+          for (int t = 2; t <= lcm_sym62__; ++t) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 10;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable p");}
+        } 
+        current_statement__ = 15;
+        if (logical_gte(lcm_sym60__, lcm_sym78__)) {
+          lcm_sym72__ = inv_logit(
+                          (lcm_sym73__ +
+                            rvalue(epsilon,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "epsilon")));
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym78__), nil_index_list())),
+            lcm_sym72__, "assigning variable phi");
+          lcm_sym68__ = (lcm_sym78__ + 1);
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym78__), nil_index_list())), mean_p,
+            "assigning variable p");
+          for (int t = lcm_sym68__; t <= lcm_sym60__; ++t) {
+            current_statement__ = 12;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), lcm_sym72__,
+              "assigning variable phi");
+            current_statement__ = 13;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), mean_p,
+              "assigning variable p");}
+        } 
+        for (int i = 2; i <= nind; ++i) {
+          lcm_sym77__ = rvalue(first,
+                          cons_list(index_uni(i), nil_index_list()), "first");
+          lcm_sym61__ = (lcm_sym77__ - 1);
+          if (logical_gte(lcm_sym61__, 1)) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 10;
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable p");
+            for (int t = 2; t <= lcm_sym61__; ++t) {
+              current_statement__ = 9;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable phi");
+              current_statement__ = 10;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable p");}
+          } 
+          current_statement__ = 15;
+          if (logical_gte(lcm_sym60__, lcm_sym77__)) {
+            lcm_sym71__ = inv_logit(
+                            (lcm_sym73__ +
+                              rvalue(epsilon,
+                                cons_list(index_uni(i), nil_index_list()),
+                                "epsilon")));
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym77__), nil_index_list())),
+              lcm_sym71__, "assigning variable phi");
+            lcm_sym67__ = (lcm_sym77__ + 1);
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym77__), nil_index_list())), mean_p,
+              "assigning variable p");
+            for (int t = lcm_sym67__; t <= lcm_sym60__; ++t) {
+              current_statement__ = 12;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), lcm_sym71__,
+                "assigning variable phi");
+              current_statement__ = 13;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), mean_p,
+                "assigning variable p");}
+          } }
+      } 
+      Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym1__;
+      int inline_sym7__;
+      inline_sym7__ = std::numeric_limits<int>::min();
+      
+      lcm_sym54__ = logical_gte(lcm_sym60__, 1);
+      inline_sym7__ = 0;
+      for (int inline_sym8__ = 1; inline_sym8__ <= 1; ++inline_sym8__) {
+        current_statement__ = 18;
+        validate_non_negative_index("chi", "nind", nind);
+        current_statement__ = 18;
+        validate_non_negative_index("chi", "n_occasions", n_occasions);
+        Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym2__;
+        inline_sym2__ = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+        stan::math::fill(inline_sym2__, DUMMY_VAR__);
+        
+        for (int inline_sym6__ = 1; inline_sym6__ <= nind; ++inline_sym6__) {
+          current_statement__ = 19;
+          assign(inline_sym2__,
+            cons_list(index_uni(inline_sym6__),
+              cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+            "assigning variable inline_sym2__");
+          if (lcm_sym54__) {
+            int inline_sym3__;
+            inline_sym3__ = std::numeric_limits<int>::min();
+            
+            int inline_sym4__;
+            inline_sym4__ = std::numeric_limits<int>::min();
+            
+            lcm_sym66__ = (lcm_sym60__ + 1);
+            current_statement__ = 22;
+            assign(inline_sym2__,
+              cons_list(index_uni(inline_sym6__),
+                cons_list(index_uni(lcm_sym60__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(inline_sym6__),
+                     cons_list(index_uni(lcm_sym60__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(inline_sym6__),
+                        cons_list(index_uni((lcm_sym66__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(inline_sym2__,
+                  cons_list(index_uni(inline_sym6__),
+                    cons_list(index_uni(lcm_sym66__), nil_index_list())),
+                  "inline_sym2__"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(inline_sym6__),
+                      cons_list(index_uni(lcm_sym60__), nil_index_list())),
+                    "phi"))), "assigning variable inline_sym2__");
+            for (int inline_sym5__ = 2; inline_sym5__ <= lcm_sym60__;
+                 ++inline_sym5__) {
+              int inline_sym3__;
+              inline_sym3__ = std::numeric_limits<int>::min();
+              
+              int inline_sym4__;
+              inline_sym4__ = std::numeric_limits<int>::min();
+              
+              lcm_sym59__ = (n_occasions - inline_sym5__);
+              lcm_sym65__ = (lcm_sym59__ + 1);
+              current_statement__ = 22;
+              assign(inline_sym2__,
+                cons_list(index_uni(inline_sym6__),
+                  cons_list(index_uni(lcm_sym59__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(inline_sym6__),
+                       cons_list(index_uni(lcm_sym59__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(inline_sym6__),
+                          cons_list(index_uni((lcm_sym65__ - 1)),
+                            nil_index_list())), "p"))),
+                  rvalue(inline_sym2__,
+                    cons_list(index_uni(inline_sym6__),
+                      cons_list(index_uni(lcm_sym65__), nil_index_list())),
+                    "inline_sym2__"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(inline_sym6__),
+                        cons_list(index_uni(lcm_sym59__), nil_index_list())),
+                      "phi"))), "assigning variable inline_sym2__");}
+          } 
+          if (inline_sym7__) {
+            break;
+          } }
+        if (inline_sym7__) {
+          break;
+        } 
+        inline_sym7__ = 1;
+        assign(inline_sym1__, nil_index_list(), inline_sym2__,
+          "assigning variable inline_sym1__");
+        break;}
+      assign(chi, nil_index_list(), inline_sym1__, "assigning variable chi");
+      if (lcm_sym54__) {
+        if (lcm_sym53__) {
+          vars__.push_back(
+            rvalue(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "phi"));
+          for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+            vars__.push_back(
+              rvalue(phi,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "phi"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= lcm_sym60__; ++sym1__) {
+          if (lcm_sym53__) {
+            vars__.push_back(
+              rvalue(phi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())), "phi"));
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              vars__.push_back(
+                rvalue(phi,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())), "phi"));
+            }
+          } }
+      } 
+      if (lcm_sym54__) {
+        if (lcm_sym53__) {
+          vars__.push_back(
+            rvalue(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "p"));
+          for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+            vars__.push_back(
+              rvalue(p,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "p"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= lcm_sym60__; ++sym1__) {
+          if (lcm_sym53__) {
+            vars__.push_back(
+              rvalue(p,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())), "p"));
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              vars__.push_back(
+                rvalue(p,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())), "p"));}
+          } }
+      } 
+      if (logical_gte(n_occasions, 1)) {
+        if (lcm_sym53__) {
+          vars__.push_back(
+            rvalue(inline_sym1__,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "inline_sym1__"));
+          for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+            vars__.push_back(
+              rvalue(inline_sym1__,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())),
+                "inline_sym1__"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          if (lcm_sym53__) {
+            vars__.push_back(
+              rvalue(inline_sym1__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                "inline_sym1__"));
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              vars__.push_back(
+                rvalue(inline_sym1__,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  "inline_sym1__"));}
+          } }
+      } 
+      vars__.push_back(lcm_sym73__);
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+      double sigma2;
+      sigma2 = std::numeric_limits<double>::quiet_NaN();
+      
+      lcm_sym74__ = square(sigma);
+      sigma2 = lcm_sym74__;
+      current_statement__ = 26;
+      current_statement__ = 26;
+      check_greater_or_equal(function__, "sigma2", lcm_sym74__, 0);
+      vars__.push_back(lcm_sym74__);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym51__;
+      double lcm_sym50__;
+      double lcm_sym49__;
+      double lcm_sym48__;
+      int lcm_sym47__;
+      int lcm_sym46__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double mean_phi;
+      mean_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mean_phi = context__.vals_r("mean_phi")[(1 - 1)];
+      current_statement__ = 1;
+      mean_phi = stan::math::lub_free(mean_phi, 0, 1);
+      double mean_p;
+      mean_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      mean_p = context__.vals_r("mean_p")[(1 - 1)];
+      current_statement__ = 2;
+      mean_p = stan::math::lub_free(mean_p, 0, 1);
+      current_statement__ = 3;
+      validate_non_negative_index("epsilon", "nind", nind);
+      Eigen::Matrix<double, -1, 1> epsilon;
+      epsilon = Eigen::Matrix<double, -1, 1>(nind);
+      stan::math::fill(epsilon, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> epsilon_flat__;
+        current_statement__ = 3;
+        assign(epsilon_flat__, nil_index_list(), context__.vals_r("epsilon"),
+          "assigning variable epsilon_flat__");
+        current_statement__ = 3;
+        pos__ = 1;
+        lcm_sym46__ = logical_gte(nind, 1);
+        if (lcm_sym46__) {
+          current_statement__ = 3;
+          assign(epsilon, cons_list(index_uni(1), nil_index_list()),
+            rvalue(epsilon_flat__, cons_list(index_uni(1), nil_index_list()),
+              "epsilon_flat__"), "assigning variable epsilon");
+          current_statement__ = 3;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+            current_statement__ = 3;
+            assign(epsilon, cons_list(index_uni(sym1__), nil_index_list()),
+              epsilon_flat__[(pos__ - 1)], "assigning variable epsilon");
+            current_statement__ = 3;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      double sigma;
+      sigma = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      sigma = context__.vals_r("sigma")[(1 - 1)];
+      current_statement__ = 4;
+      sigma = stan::math::lub_free(sigma, 0, 5);
+      vars__.push_back(mean_phi);
+      vars__.push_back(mean_p);
+      if (lcm_sym46__) {
+        vars__.push_back(
+          rvalue(epsilon, cons_list(index_uni(1), nil_index_list()),
+            "epsilon"));
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          vars__.push_back(epsilon[(sym1__ - 1)]);}
+      } 
+      vars__.push_back(sigma);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("mean_phi");
+    names__.push_back("mean_p");
+    names__.push_back("epsilon");
+    names__.push_back("sigma");
+    names__.push_back("phi");
+    names__.push_back("p");
+    names__.push_back("chi");
+    names__.push_back("mu");
+    names__.push_back("sigma2");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(nind);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(nind);
+    
+    dims__.push_back(n_occ_minus_1);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(nind);
+    
+    dims__.push_back(n_occ_minus_1);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(nind);
+    
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mean_phi");
+    param_names__.push_back(std::string() + "mean_p");
+    for (int sym155__ = 1; sym155__ <= nind; ++sym155__) {
+      {
+        param_names__.push_back(std::string() + "epsilon" + '.' + std::to_string(sym155__));
+      }}
+    param_names__.push_back(std::string() + "sigma");
+    if (emit_transformed_parameters__) {
+      for (int sym155__ = 1; sym155__ <= n_occ_minus_1; ++sym155__) {
+        {
+          for (int sym156__ = 1; sym156__ <= nind; ++sym156__) {
+            {
+              param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym156__) + '.' + std::to_string(sym155__));
+            }}
+        }}
+      for (int sym155__ = 1; sym155__ <= n_occ_minus_1; ++sym155__) {
+        {
+          for (int sym156__ = 1; sym156__ <= nind; ++sym156__) {
+            {
+              param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym156__) + '.' + std::to_string(sym155__));
+            }}
+        }}
+      for (int sym155__ = 1; sym155__ <= n_occasions; ++sym155__) {
+        {
+          for (int sym156__ = 1; sym156__ <= nind; ++sym156__) {
+            {
+              param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym156__) + '.' + std::to_string(sym155__));
+            }}
+        }}
+      param_names__.push_back(std::string() + "mu");
+    }
+    
+    if (emit_generated_quantities__) {
+      param_names__.push_back(std::string() + "sigma2");
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mean_phi");
+    param_names__.push_back(std::string() + "mean_p");
+    for (int sym155__ = 1; sym155__ <= nind; ++sym155__) {
+      {
+        param_names__.push_back(std::string() + "epsilon" + '.' + std::to_string(sym155__));
+      }}
+    param_names__.push_back(std::string() + "sigma");
+    if (emit_transformed_parameters__) {
+      for (int sym155__ = 1; sym155__ <= n_occ_minus_1; ++sym155__) {
+        {
+          for (int sym156__ = 1; sym156__ <= nind; ++sym156__) {
+            {
+              param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym156__) + '.' + std::to_string(sym155__));
+            }}
+        }}
+      for (int sym155__ = 1; sym155__ <= n_occ_minus_1; ++sym155__) {
+        {
+          for (int sym156__ = 1; sym156__ <= nind; ++sym156__) {
+            {
+              param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym156__) + '.' + std::to_string(sym155__));
+            }}
+        }}
+      for (int sym155__ = 1; sym155__ <= n_occasions; ++sym155__) {
+        {
+          for (int sym156__ = 1; sym156__ <= nind; ++sym156__) {
+            {
+              param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym156__) + '.' + std::to_string(sym155__));
+            }}
+        }}
+      param_names__.push_back(std::string() + "mu");
+    }
+    
+    if (emit_generated_quantities__) {
+      param_names__.push_back(std::string() + "sigma2");
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"epsilon\",\"type\":{\"name\":\"vector\",\"length\":" << nind << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"mu\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"epsilon\",\"type\":{\"name\":\"vector\",\"length\":" << nind << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"mu\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef expr_prop_fail5_model_namespace::expr_prop_fail5_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail6.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace expr_prop_fail6_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'expr-prop-fail6.stan', line 163, column 2 to column 33)",
+                                                      " (in 'expr-prop-fail6.stan', line 164, column 2 to column 31)",
+                                                      " (in 'expr-prop-fail6.stan', line 165, column 2 to column 28)",
+                                                      " (in 'expr-prop-fail6.stan', line 166, column 2 to column 36)",
+                                                      " (in 'expr-prop-fail6.stan', line 167, column 2 to column 20)",
+                                                      " (in 'expr-prop-fail6.stan', line 168, column 2 to column 30)",
+                                                      " (in 'expr-prop-fail6.stan', line 174, column 2 to column 50)",
+                                                      " (in 'expr-prop-fail6.stan', line 175, column 2 to column 44)",
+                                                      " (in 'expr-prop-fail6.stan', line 176, column 2 to column 25)",
+                                                      " (in 'expr-prop-fail6.stan', line 177, column 2 to column 42)",
+                                                      " (in 'expr-prop-fail6.stan', line 178, column 2 to column 46)",
+                                                      " (in 'expr-prop-fail6.stan', line 183, column 4 to column 48)",
+                                                      " (in 'expr-prop-fail6.stan', line 182, column 2 to line 183, column 48)",
+                                                      " (in 'expr-prop-fail6.stan', line 192, column 4 to column 22)",
+                                                      " (in 'expr-prop-fail6.stan', line 194, column 4 to column 17)",
+                                                      " (in 'expr-prop-fail6.stan', line 196, column 6 to column 35)",
+                                                      " (in 'expr-prop-fail6.stan', line 197, column 6 to column 27)",
+                                                      " (in 'expr-prop-fail6.stan', line 195, column 35 to line 198, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 195, column 4 to line 198, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 199, column 4 to column 26)",
+                                                      " (in 'expr-prop-fail6.stan', line 191, column 2 to line 200, column 3)",
+                                                      " (in 'expr-prop-fail6.stan', line 49, column 4 to column 24)",
+                                                      " (in 'expr-prop-fail6.stan', line 50, column 4 to column 30)",
+                                                      " (in 'expr-prop-fail6.stan', line 51, column 4 to column 35)",
+                                                      " (in 'expr-prop-fail6.stan', line 54, column 6 to column 32)",
+                                                      " (in 'expr-prop-fail6.stan', line 56, column 8 to column 37)",
+                                                      " (in 'expr-prop-fail6.stan', line 57, column 8 to column 32)",
+                                                      " (in 'expr-prop-fail6.stan', line 59, column 8 to line 60, column 65)",
+                                                      " (in 'expr-prop-fail6.stan', line 55, column 37 to line 61, column 7)",
+                                                      " (in 'expr-prop-fail6.stan', line 53, column 23 to line 62, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 48, column 47 to line 64, column 3)",
+                                                      " (in 'expr-prop-fail6.stan', line 219, column 2 to column 23)",
+                                                      " (in 'expr-prop-fail6.stan', line 220, column 2 to column 22)",
+                                                      " (in 'expr-prop-fail6.stan', line 221, column 2 to column 30)",
+                                                      " (in 'expr-prop-fail6.stan', line 222, column 2 to column 30)",
+                                                      " (in 'expr-prop-fail6.stan', line 223, column 2 to column 41)",
+                                                      " (in 'expr-prop-fail6.stan', line 229, column 4 to column 14)",
+                                                      " (in 'expr-prop-fail6.stan', line 238, column 6 to column 41)",
+                                                      " (in 'expr-prop-fail6.stan', line 237, column 11 to line 239, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 231, column 6 to column 37)",
+                                                      " (in 'expr-prop-fail6.stan', line 234, column 8 to line 235, column 46)",
+                                                      " (in 'expr-prop-fail6.stan', line 233, column 8 to column 34)",
+                                                      " (in 'expr-prop-fail6.stan', line 232, column 31 to line 236, column 7)",
+                                                      " (in 'expr-prop-fail6.stan', line 232, column 6 to line 236, column 7)",
+                                                      " (in 'expr-prop-fail6.stan', line 230, column 28 to line 237, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 230, column 4 to line 239, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 228, column 17 to line 240, column 3)",
+                                                      " (in 'expr-prop-fail6.stan', line 228, column 2 to line 240, column 3)",
+                                                      " (in 'expr-prop-fail6.stan', line 244, column 4 to column 63)",
+                                                      " (in 'expr-prop-fail6.stan', line 245, column 4 to column 16)",
+                                                      " (in 'expr-prop-fail6.stan', line 246, column 4 to column 18)",
+                                                      " (in 'expr-prop-fail6.stan', line 249, column 6 to column 36)",
+                                                      " (in 'expr-prop-fail6.stan', line 17, column 8 to column 17)",
+                                                      " (in 'expr-prop-fail6.stan', line 16, column 6 to line 17, column 17)",
+                                                      " (in 'expr-prop-fail6.stan', line 14, column 31 to line 19, column 3)",
+                                                      " (in 'expr-prop-fail6.stan', line 252, column 8 to column 26)",
+                                                      " (in 'expr-prop-fail6.stan', line 251, column 6 to line 252, column 26)",
+                                                      " (in 'expr-prop-fail6.stan', line 248, column 19 to line 253, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 248, column 4 to line 253, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 255, column 6 to column 25)",
+                                                      " (in 'expr-prop-fail6.stan', line 256, column 6 to column 31)",
+                                                      " (in 'expr-prop-fail6.stan', line 254, column 29 to line 257, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 254, column 4 to line 257, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 259, column 6 to column 26)",
+                                                      " (in 'expr-prop-fail6.stan', line 260, column 6 to column 32)",
+                                                      " (in 'expr-prop-fail6.stan', line 258, column 19 to line 261, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 258, column 4 to line 261, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 262, column 4 to column 25)",
+                                                      " (in 'expr-prop-fail6.stan', line 243, column 2 to line 263, column 3)",
+                                                      " (in 'expr-prop-fail6.stan', line 211, column 2 to column 29)",
+                                                      " (in 'expr-prop-fail6.stan', line 212, column 2 to column 21)",
+                                                      " (in 'expr-prop-fail6.stan', line 82, column 4 to column 27)",
+                                                      " (in 'expr-prop-fail6.stan', line 83, column 4 to column 33)",
+                                                      " (in 'expr-prop-fail6.stan', line 84, column 4 to column 39)",
+                                                      " (in 'expr-prop-fail6.stan', line 87, column 6 to column 43)",
+                                                      " (in 'expr-prop-fail6.stan', line 124, column 8 to column 33)",
+                                                      " (in 'expr-prop-fail6.stan', line 127, column 8 to line 130, column 47)",
+                                                      " (in 'expr-prop-fail6.stan', line 133, column 10 to line 137, column 49)",
+                                                      " (in 'expr-prop-fail6.stan', line 139, column 8 to column 54)",
+                                                      " (in 'expr-prop-fail6.stan', line 140, column 8 to column 34)",
+                                                      " (in 'expr-prop-fail6.stan', line 123, column 13 to line 141, column 7)",
+                                                      " (in 'expr-prop-fail6.stan', line 91, column 8 to column 27)",
+                                                      " (in 'expr-prop-fail6.stan', line 97, column 10 to column 30)",
+                                                      " (in 'expr-prop-fail6.stan', line 106, column 12 to line 110, column 56)",
+                                                      " (in 'expr-prop-fail6.stan', line 111, column 10 to line 113, column 61)",
+                                                      " (in 'expr-prop-fail6.stan', line 114, column 10 to column 36)",
+                                                      " (in 'expr-prop-fail6.stan', line 96, column 15 to line 115, column 9)",
+                                                      " (in 'expr-prop-fail6.stan', line 95, column 10 to column 41)",
+                                                      " (in 'expr-prop-fail6.stan', line 94, column 27 to line 96, column 9)",
+                                                      " (in 'expr-prop-fail6.stan', line 94, column 8 to line 115, column 9)",
+                                                      " (in 'expr-prop-fail6.stan', line 118, column 10 to column 39)",
+                                                      " (in 'expr-prop-fail6.stan', line 119, column 10 to column 39)",
+                                                      " (in 'expr-prop-fail6.stan', line 117, column 42 to line 120, column 9)",
+                                                      " (in 'expr-prop-fail6.stan', line 122, column 8 to column 39)",
+                                                      " (in 'expr-prop-fail6.stan', line 89, column 20 to line 123, column 7)",
+                                                      " (in 'expr-prop-fail6.stan', line 86, column 23 to line 142, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 147, column 2 to column 17)",
+                                                      " (in 'expr-prop-fail6.stan', line 148, column 2 to column 27)",
+                                                      " (in 'expr-prop-fail6.stan', line 149, column 2 to column 41)",
+                                                      " (in 'expr-prop-fail6.stan', line 153, column 2 to column 42)",
+                                                      " (in 'expr-prop-fail6.stan', line 154, column 2 to column 41)",
+                                                      " (in 'expr-prop-fail6.stan', line 157, column 4 to column 35)",
+                                                      " (in 'expr-prop-fail6.stan', line 156, column 2 to line 157, column 35)",
+                                                      " (in 'expr-prop-fail6.stan', line 30, column 6 to column 32)",
+                                                      " (in 'expr-prop-fail6.stan', line 33, column 8 to column 17)",
+                                                      " (in 'expr-prop-fail6.stan', line 32, column 6 to line 33, column 17)",
+                                                      " (in 'expr-prop-fail6.stan', line 29, column 37 to line 34, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 28, column 30 to line 36, column 3)",
+                                                      " (in 'expr-prop-fail6.stan', line 159, column 4 to column 33)",
+                                                      " (in 'expr-prop-fail6.stan', line 158, column 2 to line 159, column 33)",
+                                                      " (in 'expr-prop-fail6.stan', line 18, column 4 to column 13)",
+                                                      " (in 'expr-prop-fail6.stan', line 35, column 4 to column 13)",
+                                                      " (in 'expr-prop-fail6.stan', line 55, column 6 to line 61, column 7)",
+                                                      " (in 'expr-prop-fail6.stan', line 53, column 4 to line 62, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 63, column 4 to column 15)",
+                                                      " (in 'expr-prop-fail6.stan', line 132, column 8 to line 137, column 49)",
+                                                      " (in 'expr-prop-fail6.stan', line 105, column 10 to line 110, column 56)",
+                                                      " (in 'expr-prop-fail6.stan', line 86, column 4 to line 142, column 5)",
+                                                      " (in 'expr-prop-fail6.stan', line 81, column 42 to line 143, column 3)"};
+
+
+int
+first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym46__;
+    int lcm_sym45__;
+    int lcm_sym44__;
+    int lcm_sym43__;
+    {
+      lcm_sym44__ = size(y_i);
+      if (logical_gte(lcm_sym44__, 1)) {
+        current_statement__ = 54;
+        if (rvalue(y_i, cons_list(index_uni(1), nil_index_list()), "y_i")) {
+          current_statement__ = 53;
+          return 1;
+        } 
+        for (int k = 2; k <= lcm_sym44__; ++k) {
+          current_statement__ = 54;
+          if (rvalue(y_i, cons_list(index_uni(k), nil_index_list()), "y_i")) {
+            current_statement__ = 53;
+            return k;
+          } }
+      } 
+      current_statement__ = 111;
+      return 0;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct first_capture_functor__ {
+int
+operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+{
+return first_capture(y_i, pstream__);
+}
+};
+
+int
+last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym52__;
+    int lcm_sym51__;
+    int lcm_sym50__;
+    int lcm_sym49__;
+    int lcm_sym48__;
+    int lcm_sym47__;
+    {
+      lcm_sym50__ = (size(y_i) - 1);
+      if (logical_gte(lcm_sym50__, 0)) {
+        int k;
+        k = std::numeric_limits<int>::min();
+        
+        lcm_sym49__ = (size(y_i) - 0);
+        current_statement__ = 106;
+        if (y_i[(lcm_sym49__ - 1)]) {
+          current_statement__ = 105;
+          return lcm_sym49__;
+        } 
+        for (int k_rev = 1; k_rev <= lcm_sym50__; ++k_rev) {
+          int k;
+          k = std::numeric_limits<int>::min();
+          
+          lcm_sym48__ = (size(y_i) - k_rev);
+          current_statement__ = 106;
+          if (y_i[(lcm_sym48__ - 1)]) {
+            current_statement__ = 105;
+            return lcm_sym48__;
+          } }
+      } 
+      current_statement__ = 112;
+      return 0;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct last_capture_functor__ {
+int
+operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+{
+return last_capture(y_i, pstream__);
+}
+};
+
+template <typename T0__, typename T1__>
+Eigen::Matrix<stan::promote_args_t<T0__,
+T1__>, -1, -1>
+prob_uncaptured(const Eigen::Matrix<T0__, -1, -1>& p,
+                const Eigen::Matrix<T1__, -1, -1>& phi,
+                std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<T0__, T1__>;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym64__;
+    double lcm_sym63__;
+    double lcm_sym62__;
+    double lcm_sym61__;
+    double lcm_sym60__;
+    int lcm_sym59__;
+    int lcm_sym58__;
+    int lcm_sym57__;
+    int lcm_sym56__;
+    int lcm_sym55__;
+    int lcm_sym54__;
+    int lcm_sym53__;
+    {
+      int n_ind;
+      n_ind = std::numeric_limits<int>::min();
+      
+      lcm_sym64__ = rows(p);
+      int n_occasions;
+      n_occasions = std::numeric_limits<int>::min();
+      
+      lcm_sym59__ = cols(p);
+      n_occasions = lcm_sym59__;
+      current_statement__ = 24;
+      validate_non_negative_index("chi", "n_ind", lcm_sym64__);
+      current_statement__ = 24;
+      validate_non_negative_index("chi", "n_occasions", lcm_sym59__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(lcm_sym64__, lcm_sym59__);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      current_statement__ = 114;
+      if (logical_gte(lcm_sym64__, 1)) {
+        current_statement__ = 25;
+        assign(chi,
+          cons_list(index_uni(1),
+            cons_list(index_uni(lcm_sym59__), nil_index_list())), 1.0,
+          "assigning variable chi");
+        lcm_sym56__ = (lcm_sym59__ - 1);
+        lcm_sym53__ = logical_gte(lcm_sym56__, 1);
+        if (lcm_sym53__) {
+          int t_curr;
+          t_curr = std::numeric_limits<int>::min();
+          
+          int t_next;
+          t_next = std::numeric_limits<int>::min();
+          
+          lcm_sym58__ = (lcm_sym56__ + 1);
+          current_statement__ = 28;
+          assign(chi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym56__), nil_index_list())),
+            stan::math::fma(
+              (rvalue(phi,
+                 cons_list(index_uni(1),
+                   cons_list(index_uni(lcm_sym56__), nil_index_list())),
+                 "phi") *
+                (1 -
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym58__), nil_index_list())),
+                    "p"))),
+              rvalue(chi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(lcm_sym58__), nil_index_list())),
+                "chi"),
+              (1 -
+                rvalue(phi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym56__), nil_index_list())),
+                  "phi"))), "assigning variable chi");
+          for (int t = 2; t <= lcm_sym56__; ++t) {
+            int t_curr;
+            t_curr = std::numeric_limits<int>::min();
+            
+            lcm_sym55__ = (lcm_sym59__ - t);
+            int t_next;
+            t_next = std::numeric_limits<int>::min();
+            
+            lcm_sym57__ = (lcm_sym55__ + 1);
+            current_statement__ = 28;
+            assign(chi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(lcm_sym55__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(1),
+                     cons_list(index_uni(lcm_sym55__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(lcm_sym57__), nil_index_list())),
+                      "p"))),
+                rvalue(chi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym57__), nil_index_list())),
+                  "chi"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym55__), nil_index_list())),
+                    "phi"))), "assigning variable chi");}
+        } 
+        for (int i = 2; i <= lcm_sym64__; ++i) {
+          current_statement__ = 25;
+          assign(chi,
+            cons_list(index_uni(i),
+              cons_list(index_uni(lcm_sym59__), nil_index_list())), 1.0,
+            "assigning variable chi");
+          current_statement__ = 113;
+          if (lcm_sym53__) {
+            int t_curr;
+            t_curr = std::numeric_limits<int>::min();
+            
+            int t_next;
+            t_next = std::numeric_limits<int>::min();
+            
+            lcm_sym58__ = (lcm_sym56__ + 1);
+            current_statement__ = 28;
+            assign(chi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym56__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(i),
+                     cons_list(index_uni(lcm_sym56__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym58__), nil_index_list())),
+                      "p"))),
+                rvalue(chi,
+                  cons_list(index_uni(i),
+                    cons_list(index_uni(lcm_sym58__), nil_index_list())),
+                  "chi"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym56__), nil_index_list())),
+                    "phi"))), "assigning variable chi");
+            for (int t = 2; t <= lcm_sym56__; ++t) {
+              int t_curr;
+              t_curr = std::numeric_limits<int>::min();
+              
+              lcm_sym55__ = (lcm_sym59__ - t);
+              int t_next;
+              t_next = std::numeric_limits<int>::min();
+              
+              lcm_sym57__ = (lcm_sym55__ + 1);
+              current_statement__ = 28;
+              assign(chi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(lcm_sym55__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(i),
+                       cons_list(index_uni(lcm_sym55__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni(lcm_sym57__), nil_index_list())),
+                        "p"))),
+                  rvalue(chi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym57__), nil_index_list())),
+                    "chi"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym55__), nil_index_list())),
+                      "phi"))), "assigning variable chi");}
+          } }
+      } 
+      current_statement__ = 115;
+      return chi;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct prob_uncaptured_functor__ {
+template <typename T0__, typename T1__>
+Eigen::Matrix<stan::promote_args_t<T0__,
+T1__>, -1, -1>
+operator()(const Eigen::Matrix<T0__, -1, -1>& p,
+           const Eigen::Matrix<T1__, -1, -1>& phi, std::ostream* pstream__)  const 
+{
+return prob_uncaptured(p, phi, pstream__);
+}
+};
+
+template <bool propto__, typename T3__, typename T4__, typename T5__,
+typename T6__, typename T7__, typename T_lp__, typename T_lp_accum__>
+void
+js_super_lp(const std::vector<std::vector<int>>& y,
+            const std::vector<int>& first, const std::vector<int>& last,
+            const Eigen::Matrix<T3__, -1, -1>& p,
+            const Eigen::Matrix<T4__, -1, -1>& phi, const T5__& psi,
+            const Eigen::Matrix<T6__, -1, 1>& nu,
+            const Eigen::Matrix<T7__, -1, -1>& chi, T_lp__& lp__,
+            T_lp_accum__& lp_accum__, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<T3__,
+          T4__,
+          T5__,
+          T6__,
+          T7__>;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym115__;
+    int lcm_sym114__;
+    int lcm_sym113__;
+    int lcm_sym112__;
+    int lcm_sym111__;
+    int lcm_sym110__;
+    double lcm_sym109__;
+    double lcm_sym108__;
+    double lcm_sym107__;
+    double lcm_sym106__;
+    double lcm_sym105__;
+    double lcm_sym104__;
+    double lcm_sym103__;
+    double lcm_sym102__;
+    double lcm_sym101__;
+    double lcm_sym100__;
+    double lcm_sym99__;
+    double lcm_sym98__;
+    double lcm_sym97__;
+    double lcm_sym96__;
+    double lcm_sym95__;
+    int lcm_sym94__;
+    int lcm_sym93__;
+    int lcm_sym92__;
+    double lcm_sym91__;
+    double lcm_sym90__;
+    double lcm_sym89__;
+    double lcm_sym88__;
+    double lcm_sym87__;
+    double lcm_sym86__;
+    double lcm_sym85__;
+    double lcm_sym84__;
+    double lcm_sym83__;
+    double lcm_sym82__;
+    double lcm_sym81__;
+    double lcm_sym80__;
+    double lcm_sym79__;
+    double lcm_sym78__;
+    int lcm_sym77__;
+    int lcm_sym76__;
+    Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym75__;
+    Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym74__;
+    Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym73__;
+    int lcm_sym72__;
+    int lcm_sym71__;
+    int lcm_sym70__;
+    int lcm_sym69__;
+    int lcm_sym68__;
+    int lcm_sym67__;
+    int lcm_sym66__;
+    int lcm_sym65__;
+    {
+      int n_ind;
+      n_ind = std::numeric_limits<int>::min();
+      
+      lcm_sym114__ = rvalue(dims(y),
+                       cons_list(index_uni(1), nil_index_list()), "dims(y)");
+      int n_occasions;
+      n_occasions = std::numeric_limits<int>::min();
+      
+      lcm_sym115__ = rvalue(dims(y),
+                       cons_list(index_uni(2), nil_index_list()), "dims(y)");
+      n_occasions = lcm_sym115__;
+      current_statement__ = 74;
+      validate_non_negative_index("qnu", "n_occasions", lcm_sym115__);
+      Eigen::Matrix<double, -1, 1> qnu;
+      qnu = Eigen::Matrix<double, -1, 1>(lcm_sym115__);
+      stan::math::fill(qnu, std::numeric_limits<double>::quiet_NaN());
+      
+      assign(lcm_sym73__, nil_index_list(), subtract(1.0, nu),
+        "assigning variable lcm_sym73__");
+      current_statement__ = 118;
+      if (logical_gte(lcm_sym114__, 1)) {
+        current_statement__ = 75;
+        validate_non_negative_index("qp", "n_occasions", lcm_sym115__);
+        Eigen::Matrix<double, -1, 1> qp;
+        qp = Eigen::Matrix<double, -1, 1>(lcm_sym115__);
+        stan::math::fill(qp, std::numeric_limits<double>::quiet_NaN());
+        
+        assign(lcm_sym75__, nil_index_list(),
+          subtract(1.0,
+            transpose(
+              rvalue(p, cons_list(index_uni(1), nil_index_list()), "p"))),
+          "assigning variable lcm_sym75__");
+        lcm_sym111__ = rvalue(first,
+                         cons_list(index_uni(1), nil_index_list()), "first");
+        if (lcm_sym111__) {
+          current_statement__ = 82;
+          lp_accum__.add(bernoulli_log<propto__>(1, psi));
+          current_statement__ = 90;
+          if (logical_eq(lcm_sym111__, 1)) {
+            current_statement__ = 88;
+            lp_accum__.add(
+              bernoulli_log<propto__>(1,
+                (rvalue(nu, cons_list(index_uni(1), nil_index_list()), "nu")
+                  *
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(1), nil_index_list())), "p"))));
+          } else {
+            current_statement__ = 83;
+            validate_non_negative_index("lp",
+                                        "rvalue(first, cons_list(index_uni(i), nil_index_list()), \"first\")",
+                                        lcm_sym111__);
+            Eigen::Matrix<local_scalar_t__, -1, 1> lp;
+            lp = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym111__);
+            stan::math::fill(lp, DUMMY_VAR__);
+            
+            lcm_sym77__ = (lcm_sym111__ - 1);
+            assign(lp, cons_list(index_uni(1), nil_index_list()),
+              (((bernoulli_lpmf<false>(1,
+                   rvalue(nu, cons_list(index_uni(1), nil_index_list()),
+                     "nu")) +
+                  bernoulli_lpmf<false>(1,
+                    prod(
+                      rvalue(lcm_sym75__,
+                        cons_list(index_min_max(1, lcm_sym77__),
+                          nil_index_list()), "lcm_sym75__")))) +
+                 bernoulli_lpmf<false>(1,
+                   prod(
+                     rvalue(phi,
+                       cons_list(index_uni(1),
+                         cons_list(index_min_max(1, lcm_sym77__),
+                           nil_index_list())), "phi")))) +
+                bernoulli_lpmf<false>(1,
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym111__), nil_index_list())),
+                    "p"))), "assigning variable lp");
+            current_statement__ = 117;
+            if (logical_gte(lcm_sym77__, 2)) {
+              current_statement__ = 84;
+              assign(lp, cons_list(index_uni(2), nil_index_list()),
+                ((((bernoulli_lpmf<false>(1,
+                      prod(
+                        rvalue(lcm_sym73__,
+                          cons_list(index_min_max(1, 1), nil_index_list()),
+                          "lcm_sym73__"))) +
+                     bernoulli_lpmf<false>(1,
+                       rvalue(nu, cons_list(index_uni(2), nil_index_list()),
+                         "nu"))) +
+                    bernoulli_lpmf<false>(1,
+                      prod(
+                        rvalue(lcm_sym75__,
+                          cons_list(index_min_max(2, lcm_sym77__),
+                            nil_index_list()), "lcm_sym75__")))) +
+                   bernoulli_lpmf<false>(1,
+                     prod(
+                       rvalue(phi,
+                         cons_list(index_uni(1),
+                           cons_list(index_min_max(2, lcm_sym77__),
+                             nil_index_list())), "phi")))) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(p,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(lcm_sym111__), nil_index_list())),
+                      "p"))), "assigning variable lp");
+              for (int t = 3; t <= lcm_sym77__; ++t) {
+                current_statement__ = 84;
+                assign(lp, cons_list(index_uni(t), nil_index_list()),
+                  ((((bernoulli_lpmf<false>(1,
+                        prod(
+                          rvalue(lcm_sym73__,
+                            cons_list(index_min_max(1, (t - 1)),
+                              nil_index_list()), "lcm_sym73__"))) +
+                       bernoulli_lpmf<false>(1,
+                         rvalue(nu,
+                           cons_list(index_uni(t), nil_index_list()), "nu")))
+                      +
+                      bernoulli_lpmf<false>(1,
+                        prod(
+                          rvalue(lcm_sym75__,
+                            cons_list(index_min_max(t, lcm_sym77__),
+                              nil_index_list()), "lcm_sym75__")))) +
+                     bernoulli_lpmf<false>(1,
+                       prod(
+                         rvalue(phi,
+                           cons_list(index_uni(1),
+                             cons_list(index_min_max(t, lcm_sym77__),
+                               nil_index_list())), "phi")))) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(p,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(lcm_sym111__),
+                            nil_index_list())), "p"))),
+                  "assigning variable lp");}
+            } 
+            current_statement__ = 85;
+            assign(lp, cons_list(index_uni(lcm_sym111__), nil_index_list()),
+              ((bernoulli_lpmf<false>(1,
+                  prod(
+                    rvalue(lcm_sym73__,
+                      cons_list(index_min_max(1, lcm_sym77__),
+                        nil_index_list()), "lcm_sym73__"))) +
+                 bernoulli_lpmf<false>(1, nu[(lcm_sym111__ - 1)])) +
+                bernoulli_lpmf<false>(1,
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym111__), nil_index_list())),
+                    "p"))), "assigning variable lp");
+            current_statement__ = 86;
+            lp_accum__.add(log_sum_exp(lp));
+          }
+          lcm_sym113__ = rvalue(last,
+                           cons_list(index_uni(1), nil_index_list()), "last");
+          if (logical_gte(lcm_sym113__, (lcm_sym111__ + 1))) {
+            current_statement__ = 91;
+            lp_accum__.add(
+              bernoulli_log<propto__>(1,
+                rvalue(phi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(((lcm_sym111__ + 1) - 1)),
+                      nil_index_list())), "phi")));
+            lcm_sym93__ = ((lcm_sym111__ + 1) + 1);
+            lp_accum__.add(
+              bernoulli_log<propto__>(
+                rvalue(y,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni((lcm_sym111__ + 1)),
+                      nil_index_list())), "y"),
+                rvalue(p,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni((lcm_sym111__ + 1)),
+                      nil_index_list())), "p")));
+            for (int t = lcm_sym93__; t <= lcm_sym113__; ++t) {
+              current_statement__ = 91;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(phi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((t - 1)), nil_index_list())),
+                    "phi")));
+              current_statement__ = 92;
+              lp_accum__.add(
+                bernoulli_log<propto__>(
+                  rvalue(y,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(t), nil_index_list())), "y"),
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(t), nil_index_list())), "p")));}
+          } 
+          current_statement__ = 94;
+          lp_accum__.add(
+            bernoulli_log<propto__>(1,
+              rvalue(chi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(lcm_sym113__), nil_index_list())),
+                "chi")));
+        } else {
+          lcm_sym94__ = (lcm_sym115__ + 1);
+          validate_non_negative_index("lp", "(n_occasions + 1)", lcm_sym94__);
+          Eigen::Matrix<local_scalar_t__, -1, 1> lp;
+          lp = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym94__);
+          stan::math::fill(lp, DUMMY_VAR__);
+          
+          current_statement__ = 77;
+          assign(lp, cons_list(index_uni(1), nil_index_list()),
+            (((bernoulli_lpmf<false>(1, psi) +
+                bernoulli_lpmf<false>(1,
+                  rvalue(nu, cons_list(index_uni(1), nil_index_list()), "nu")))
+               +
+               bernoulli_lpmf<false>(0,
+                 rvalue(p,
+                   cons_list(index_uni(1),
+                     cons_list(index_uni(1), nil_index_list())), "p"))) +
+              bernoulli_lpmf<false>(1,
+                rvalue(chi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(1), nil_index_list())), "chi"))),
+            "assigning variable lp");
+          current_statement__ = 116;
+          if (logical_gte(lcm_sym115__, 2)) {
+            current_statement__ = 78;
+            assign(lp, cons_list(index_uni(2), nil_index_list()),
+              ((((bernoulli_lpmf<false>(1, psi) +
+                   bernoulli_lpmf<false>(1,
+                     prod(
+                       rvalue(lcm_sym73__,
+                         cons_list(index_min_max(1, 1), nil_index_list()),
+                         "lcm_sym73__")))) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(nu, cons_list(index_uni(2), nil_index_list()),
+                      "nu"))) +
+                 bernoulli_lpmf<false>(0,
+                   rvalue(p,
+                     cons_list(index_uni(1),
+                       cons_list(index_uni(2), nil_index_list())), "p"))) +
+                bernoulli_lpmf<false>(1,
+                  rvalue(chi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(2), nil_index_list())), "chi"))),
+              "assigning variable lp");
+            for (int t = 3; t <= lcm_sym115__; ++t) {
+              current_statement__ = 78;
+              assign(lp, cons_list(index_uni(t), nil_index_list()),
+                ((((bernoulli_lpmf<false>(1, psi) +
+                     bernoulli_lpmf<false>(1,
+                       prod(
+                         rvalue(lcm_sym73__,
+                           cons_list(index_min_max(1, (t - 1)),
+                             nil_index_list()), "lcm_sym73__")))) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(nu, cons_list(index_uni(t), nil_index_list()),
+                        "nu"))) +
+                   bernoulli_lpmf<false>(0,
+                     rvalue(p,
+                       cons_list(index_uni(1),
+                         cons_list(index_uni(t), nil_index_list())), "p"))) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(chi,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(t), nil_index_list())), "chi"))),
+                "assigning variable lp");}
+          } 
+          current_statement__ = 79;
+          assign(lp, cons_list(index_uni(lcm_sym94__), nil_index_list()),
+            bernoulli_lpmf<false>(0, psi), "assigning variable lp");
+          current_statement__ = 80;
+          lp_accum__.add(log_sum_exp(lp));
+        }
+        for (int i = 2; i <= lcm_sym114__; ++i) {
+          current_statement__ = 75;
+          validate_non_negative_index("qp", "n_occasions", lcm_sym115__);
+          Eigen::Matrix<double, -1, 1> qp;
+          qp = Eigen::Matrix<double, -1, 1>(lcm_sym115__);
+          stan::math::fill(qp, std::numeric_limits<double>::quiet_NaN());
+          
+          assign(lcm_sym74__, nil_index_list(),
+            subtract(1.0,
+              transpose(
+                rvalue(p, cons_list(index_uni(i), nil_index_list()), "p"))),
+            "assigning variable lcm_sym74__");
+          lcm_sym110__ = rvalue(first,
+                           cons_list(index_uni(i), nil_index_list()),
+                           "first");
+          if (lcm_sym110__) {
+            current_statement__ = 82;
+            lp_accum__.add(bernoulli_log<propto__>(1, psi));
+            current_statement__ = 90;
+            if (logical_eq(lcm_sym110__, 1)) {
+              current_statement__ = 88;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  (rvalue(nu, cons_list(index_uni(1), nil_index_list()),
+                     "nu") *
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(1), nil_index_list())), "p"))));
+            } else {
+              current_statement__ = 83;
+              validate_non_negative_index("lp",
+                                          "rvalue(first, cons_list(index_uni(i), nil_index_list()), \"first\")",
+                                          lcm_sym110__);
+              Eigen::Matrix<local_scalar_t__, -1, 1> lp;
+              lp = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym110__);
+              stan::math::fill(lp, DUMMY_VAR__);
+              
+              lcm_sym76__ = (lcm_sym110__ - 1);
+              assign(lp, cons_list(index_uni(1), nil_index_list()),
+                (((bernoulli_lpmf<false>(1,
+                     rvalue(nu, cons_list(index_uni(1), nil_index_list()),
+                       "nu")) +
+                    bernoulli_lpmf<false>(1,
+                      prod(
+                        rvalue(lcm_sym74__,
+                          cons_list(index_min_max(1, lcm_sym76__),
+                            nil_index_list()), "lcm_sym74__")))) +
+                   bernoulli_lpmf<false>(1,
+                     prod(
+                       rvalue(phi,
+                         cons_list(index_uni(i),
+                           cons_list(index_min_max(1, lcm_sym76__),
+                             nil_index_list())), "phi")))) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym110__), nil_index_list())),
+                      "p"))), "assigning variable lp");
+              current_statement__ = 117;
+              if (logical_gte(lcm_sym76__, 2)) {
+                current_statement__ = 84;
+                assign(lp, cons_list(index_uni(2), nil_index_list()),
+                  ((((bernoulli_lpmf<false>(1,
+                        prod(
+                          rvalue(lcm_sym73__,
+                            cons_list(index_min_max(1, 1), nil_index_list()),
+                            "lcm_sym73__"))) +
+                       bernoulli_lpmf<false>(1,
+                         rvalue(nu,
+                           cons_list(index_uni(2), nil_index_list()), "nu")))
+                      +
+                      bernoulli_lpmf<false>(1,
+                        prod(
+                          rvalue(lcm_sym74__,
+                            cons_list(index_min_max(2, lcm_sym76__),
+                              nil_index_list()), "lcm_sym74__")))) +
+                     bernoulli_lpmf<false>(1,
+                       prod(
+                         rvalue(phi,
+                           cons_list(index_uni(i),
+                             cons_list(index_min_max(2, lcm_sym76__),
+                               nil_index_list())), "phi")))) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(p,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni(lcm_sym110__),
+                            nil_index_list())), "p"))),
+                  "assigning variable lp");
+                for (int t = 3; t <= lcm_sym76__; ++t) {
+                  current_statement__ = 84;
+                  assign(lp, cons_list(index_uni(t), nil_index_list()),
+                    ((((bernoulli_lpmf<false>(1,
+                          prod(
+                            rvalue(lcm_sym73__,
+                              cons_list(index_min_max(1, (t - 1)),
+                                nil_index_list()), "lcm_sym73__"))) +
+                         bernoulli_lpmf<false>(1,
+                           rvalue(nu,
+                             cons_list(index_uni(t), nil_index_list()), "nu")))
+                        +
+                        bernoulli_lpmf<false>(1,
+                          prod(
+                            rvalue(lcm_sym74__,
+                              cons_list(index_min_max(t, lcm_sym76__),
+                                nil_index_list()), "lcm_sym74__")))) +
+                       bernoulli_lpmf<false>(1,
+                         prod(
+                           rvalue(phi,
+                             cons_list(index_uni(i),
+                               cons_list(index_min_max(t, lcm_sym76__),
+                                 nil_index_list())), "phi")))) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(p,
+                          cons_list(index_uni(i),
+                            cons_list(index_uni(lcm_sym110__),
+                              nil_index_list())), "p"))),
+                    "assigning variable lp");}
+              } 
+              current_statement__ = 85;
+              assign(lp,
+                cons_list(index_uni(lcm_sym110__), nil_index_list()),
+                ((bernoulli_lpmf<false>(1,
+                    prod(
+                      rvalue(lcm_sym73__,
+                        cons_list(index_min_max(1, lcm_sym76__),
+                          nil_index_list()), "lcm_sym73__"))) +
+                   bernoulli_lpmf<false>(1, nu[(lcm_sym110__ - 1)])) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym110__), nil_index_list())),
+                      "p"))), "assigning variable lp");
+              current_statement__ = 86;
+              lp_accum__.add(log_sum_exp(lp));
+            }
+            lcm_sym112__ = rvalue(last,
+                             cons_list(index_uni(i), nil_index_list()),
+                             "last");
+            if (logical_gte(lcm_sym112__, (lcm_sym110__ + 1))) {
+              current_statement__ = 91;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(phi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(((lcm_sym110__ + 1) - 1)),
+                        nil_index_list())), "phi")));
+              lcm_sym92__ = ((lcm_sym110__ + 1) + 1);
+              lp_accum__.add(
+                bernoulli_log<propto__>(
+                  rvalue(y,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni((lcm_sym110__ + 1)),
+                        nil_index_list())), "y"),
+                  rvalue(p,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni((lcm_sym110__ + 1)),
+                        nil_index_list())), "p")));
+              for (int t = lcm_sym92__; t <= lcm_sym112__; ++t) {
+                current_statement__ = 91;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(phi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((t - 1)), nil_index_list())),
+                      "phi")));
+                current_statement__ = 92;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(
+                    rvalue(y,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(t), nil_index_list())), "y"),
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(t), nil_index_list())), "p")));}
+            } 
+            current_statement__ = 94;
+            lp_accum__.add(
+              bernoulli_log<propto__>(1,
+                rvalue(chi,
+                  cons_list(index_uni(i),
+                    cons_list(index_uni(lcm_sym112__), nil_index_list())),
+                  "chi")));
+          } else {
+            lcm_sym94__ = (lcm_sym115__ + 1);
+            validate_non_negative_index("lp", "(n_occasions + 1)",
+                                        lcm_sym94__);
+            Eigen::Matrix<local_scalar_t__, -1, 1> lp;
+            lp = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym94__);
+            stan::math::fill(lp, DUMMY_VAR__);
+            
+            current_statement__ = 77;
+            assign(lp, cons_list(index_uni(1), nil_index_list()),
+              (((bernoulli_lpmf<false>(1, psi) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(nu, cons_list(index_uni(1), nil_index_list()),
+                      "nu"))) +
+                 bernoulli_lpmf<false>(0,
+                   rvalue(p,
+                     cons_list(index_uni(i),
+                       cons_list(index_uni(1), nil_index_list())), "p"))) +
+                bernoulli_lpmf<false>(1,
+                  rvalue(chi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(1), nil_index_list())), "chi"))),
+              "assigning variable lp");
+            current_statement__ = 116;
+            if (logical_gte(lcm_sym115__, 2)) {
+              current_statement__ = 78;
+              assign(lp, cons_list(index_uni(2), nil_index_list()),
+                ((((bernoulli_lpmf<false>(1, psi) +
+                     bernoulli_lpmf<false>(1,
+                       prod(
+                         rvalue(lcm_sym73__,
+                           cons_list(index_min_max(1, 1), nil_index_list()),
+                           "lcm_sym73__")))) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(nu, cons_list(index_uni(2), nil_index_list()),
+                        "nu"))) +
+                   bernoulli_lpmf<false>(0,
+                     rvalue(p,
+                       cons_list(index_uni(i),
+                         cons_list(index_uni(2), nil_index_list())), "p"))) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(chi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(2), nil_index_list())), "chi"))),
+                "assigning variable lp");
+              for (int t = 3; t <= lcm_sym115__; ++t) {
+                current_statement__ = 78;
+                assign(lp, cons_list(index_uni(t), nil_index_list()),
+                  ((((bernoulli_lpmf<false>(1, psi) +
+                       bernoulli_lpmf<false>(1,
+                         prod(
+                           rvalue(lcm_sym73__,
+                             cons_list(index_min_max(1, (t - 1)),
+                               nil_index_list()), "lcm_sym73__")))) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(nu, cons_list(index_uni(t), nil_index_list()),
+                          "nu"))) +
+                     bernoulli_lpmf<false>(0,
+                       rvalue(p,
+                         cons_list(index_uni(i),
+                           cons_list(index_uni(t), nil_index_list())), "p")))
+                    +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(chi,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni(t), nil_index_list())), "chi"))),
+                  "assigning variable lp");}
+            } 
+            current_statement__ = 79;
+            assign(lp, cons_list(index_uni(lcm_sym94__), nil_index_list()),
+              bernoulli_lpmf<false>(0, psi), "assigning variable lp");
+            current_statement__ = 80;
+            lp_accum__.add(log_sum_exp(lp));
+          }}
+      } 
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct js_super_lp_functor__ {
+template <bool propto__, typename T3__, typename T4__, typename T5__,
+typename T6__, typename T7__, typename T_lp__, typename T_lp_accum__>
+void
+operator()(const std::vector<std::vector<int>>& y,
+           const std::vector<int>& first, const std::vector<int>& last,
+           const Eigen::Matrix<T3__, -1, -1>& p,
+           const Eigen::Matrix<T4__, -1, -1>& phi, const T5__& psi,
+           const Eigen::Matrix<T6__, -1, 1>& nu,
+           const Eigen::Matrix<T7__, -1, -1>& chi, T_lp__& lp__,
+           T_lp_accum__& lp_accum__, std::ostream* pstream__)  const 
+{
+return js_super_lp(y, first, last, p, phi, psi, nu, chi, lp__, lp_accum__,
+         pstream__);
+}
+};
+
+class expr_prop_fail6_model : public model_base_crtp<expr_prop_fail6_model> {
+
+ private:
+  int lcm_sym312__;
+  int lcm_sym311__;
+  int lcm_sym310__;
+  int lcm_sym309__;
+  int lcm_sym308__;
+  int lcm_sym307__;
+  int lcm_sym306__;
+  int lcm_sym305__;
+  int lcm_sym304__;
+  int lcm_sym303__;
+  int lcm_sym302__;
+  int lcm_sym301__;
+  int lcm_sym300__;
+  int lcm_sym299__;
+  int lcm_sym298__;
+  int lcm_sym297__;
+  int lcm_sym296__;
+  int lcm_sym295__;
+  int lcm_sym294__;
+  int lcm_sym293__;
+  int lcm_sym292__;
+  int lcm_sym291__;
+  int lcm_sym290__;
+  int pos__;
+  int M;
+  int n_occasions;
+  std::vector<std::vector<int>> y;
+  std::vector<int> first;
+  std::vector<int> last;
+ 
+ public:
+  ~expr_prop_fail6_model() { }
+  
+  std::string model_name() const { return "expr_prop_fail6_model"; }
+  
+  expr_prop_fail6_model(stan::io::var_context& context__,
+                        unsigned int random_seed__ = 0,
+                        std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "expr_prop_fail6_model_namespace::expr_prop_fail6_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","M","int",
+          context__.to_vec());
+      M = std::numeric_limits<int>::min();
+      
+      current_statement__ = 97;
+      M = context__.vals_i("M")[(1 - 1)];
+      context__.validate_dims("data initialization","n_occasions","int",
+          context__.to_vec());
+      n_occasions = std::numeric_limits<int>::min();
+      
+      current_statement__ = 98;
+      n_occasions = context__.vals_i("n_occasions")[(1 - 1)];
+      current_statement__ = 99;
+      validate_non_negative_index("y", "M", M);
+      current_statement__ = 99;
+      validate_non_negative_index("y", "n_occasions", n_occasions);
+      context__.validate_dims("data initialization","y","int",
+          context__.to_vec(M, n_occasions));
+      y = std::vector<std::vector<int>>(M, std::vector<int>(n_occasions, std::numeric_limits<int>::min()));
+      
+      {
+        std::vector<int> y_flat__;
+        current_statement__ = 99;
+        assign(y_flat__, nil_index_list(), context__.vals_i("y"),
+          "assigning variable y_flat__");
+        current_statement__ = 99;
+        pos__ = 1;
+        lcm_sym291__ = logical_gte(n_occasions, 1);
+        if (lcm_sym291__) {
+          {
+            lcm_sym290__ = logical_gte(M, 1);
+            if (lcm_sym290__) {
+              current_statement__ = 99;
+              assign(y,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(1), nil_index_list())),
+                rvalue(y_flat__, cons_list(index_uni(1), nil_index_list()),
+                  "y_flat__"), "assigning variable y");
+              current_statement__ = 99;
+              pos__ = 2;
+              for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+                current_statement__ = 99;
+                assign(y,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(1), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 99;
+                pos__ = (pos__ + 1);}
+            } 
+            for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+              current_statement__ = 99;
+              if (lcm_sym290__) {
+                current_statement__ = 99;
+                assign(y,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 99;
+                pos__ = (pos__ + 1);
+                for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+                  current_statement__ = 99;
+                  assign(y,
+                    cons_list(index_uni(sym2__),
+                      cons_list(index_uni(sym1__), nil_index_list())),
+                    y_flat__[(pos__ - 1)], "assigning variable y");
+                  current_statement__ = 99;
+                  pos__ = (pos__ + 1);}
+              } }
+          }
+        } else {
+          lcm_sym290__ = logical_gte(M, 1);
+        }
+      }
+      current_statement__ = 100;
+      validate_non_negative_index("first", "M", M);
+      first = std::vector<int>(M, std::numeric_limits<int>::min());
+      
+      current_statement__ = 101;
+      validate_non_negative_index("last", "M", M);
+      last = std::vector<int>(M, std::numeric_limits<int>::min());
+      
+      current_statement__ = 103;
+      if (lcm_sym290__) {
+        int inline_sym34__;
+        int inline_sym36__;
+        inline_sym36__ = std::numeric_limits<int>::min();
+        
+        inline_sym36__ = 0;
+        for (int inline_sym37__ = 1; inline_sym37__ <= 1; ++inline_sym37__) {
+          lcm_sym298__ = size(
+                           rvalue(y,
+                             cons_list(index_uni(1), nil_index_list()), "y"));
+          for (int inline_sym35__ = 1; inline_sym35__ <= lcm_sym298__;
+               ++inline_sym35__) {
+            current_statement__ = 54;
+            if (rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")[
+                (inline_sym35__ - 1)]) {
+              inline_sym36__ = 1;
+              inline_sym34__ = inline_sym35__;
+              break;
+            } }
+          if (inline_sym36__) {
+            break;
+          } 
+          inline_sym36__ = 1;
+          inline_sym34__ = 0;
+          break;}
+        assign(first, cons_list(index_uni(1), nil_index_list()),
+          inline_sym34__, "assigning variable first");
+        for (int i = 2; i <= M; ++i) {
+          int inline_sym34__;
+          int inline_sym36__;
+          inline_sym36__ = std::numeric_limits<int>::min();
+          
+          inline_sym36__ = 0;
+          for (int inline_sym37__ = 1; inline_sym37__ <= 1; ++inline_sym37__) {
+            lcm_sym297__ = size(
+                             rvalue(y,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "y"));
+            for (int inline_sym35__ = 1; inline_sym35__ <= lcm_sym297__;
+                 ++inline_sym35__) {
+              current_statement__ = 54;
+              if (rvalue(y, cons_list(index_uni(i), nil_index_list()), "y")[
+                  (inline_sym35__ - 1)]) {
+                inline_sym36__ = 1;
+                inline_sym34__ = inline_sym35__;
+                break;
+              } }
+            if (inline_sym36__) {
+              break;
+            } 
+            inline_sym36__ = 1;
+            inline_sym34__ = 0;
+            break;}
+          assign(first, cons_list(index_uni(i), nil_index_list()),
+            inline_sym34__, "assigning variable first");}
+      } 
+      current_statement__ = 110;
+      if (lcm_sym290__) {
+        int inline_sym38__;
+        int inline_sym41__;
+        inline_sym41__ = std::numeric_limits<int>::min();
+        
+        inline_sym41__ = 0;
+        for (int inline_sym42__ = 1; inline_sym42__ <= 1; ++inline_sym42__) {
+          lcm_sym298__ = size(
+                           rvalue(y,
+                             cons_list(index_uni(1), nil_index_list()), "y"));
+          lcm_sym295__ = (lcm_sym298__ - 1);
+          for (int inline_sym40__ = 0; inline_sym40__ <= lcm_sym295__;
+               ++inline_sym40__) {
+            int inline_sym39__;
+            inline_sym39__ = std::numeric_limits<int>::min();
+            
+            lcm_sym294__ = (lcm_sym298__ - inline_sym40__);
+            inline_sym39__ = lcm_sym294__;
+            current_statement__ = 106;
+            if (rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")[
+                (lcm_sym294__ - 1)]) {
+              inline_sym41__ = 1;
+              inline_sym38__ = lcm_sym294__;
+              break;
+            } }
+          if (inline_sym41__) {
+            break;
+          } 
+          inline_sym41__ = 1;
+          inline_sym38__ = 0;
+          break;}
+        assign(last, cons_list(index_uni(1), nil_index_list()),
+          inline_sym38__, "assigning variable last");
+        for (int i = 2; i <= M; ++i) {
+          int inline_sym38__;
+          int inline_sym41__;
+          inline_sym41__ = std::numeric_limits<int>::min();
+          
+          inline_sym41__ = 0;
+          for (int inline_sym42__ = 1; inline_sym42__ <= 1; ++inline_sym42__) {
+            lcm_sym297__ = size(
+                             rvalue(y,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "y"));
+            lcm_sym293__ = (lcm_sym297__ - 1);
+            for (int inline_sym40__ = 0; inline_sym40__ <= lcm_sym293__;
+                 ++inline_sym40__) {
+              int inline_sym39__;
+              inline_sym39__ = std::numeric_limits<int>::min();
+              
+              lcm_sym292__ = (lcm_sym297__ - inline_sym40__);
+              inline_sym39__ = lcm_sym292__;
+              current_statement__ = 106;
+              if (rvalue(y, cons_list(index_uni(i), nil_index_list()), "y")[
+                  (lcm_sym292__ - 1)]) {
+                inline_sym41__ = 1;
+                inline_sym38__ = lcm_sym292__;
+                break;
+              } }
+            if (inline_sym41__) {
+              break;
+            } 
+            inline_sym41__ = 1;
+            inline_sym38__ = 0;
+            break;}
+          assign(last, cons_list(index_uni(i), nil_index_list()),
+            inline_sym38__, "assigning variable last");}
+      } 
+      current_statement__ = 97;
+      current_statement__ = 97;
+      check_greater_or_equal(function__, "M", M, 0);
+      current_statement__ = 98;
+      current_statement__ = 98;
+      check_greater_or_equal(function__, "n_occasions", n_occasions, 0);
+      current_statement__ = 99;
+      if (lcm_sym290__) {
+        current_statement__ = 99;
+        if (lcm_sym291__) {
+          current_statement__ = 99;
+          current_statement__ = 99;
+          check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                 rvalue(y,
+                                   cons_list(index_uni(1),
+                                     cons_list(index_uni(1),
+                                       nil_index_list())), "y"), 0);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 99;
+            current_statement__ = 99;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(1),
+                                       cons_list(index_uni(sym2__),
+                                         nil_index_list())), "y"), 0);}
+        } 
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 99;
+          if (lcm_sym291__) {
+            current_statement__ = 99;
+            current_statement__ = 99;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(sym1__),
+                                       cons_list(index_uni(1),
+                                         nil_index_list())), "y"), 0);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 99;
+              current_statement__ = 99;
+              check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                     y[(sym1__ - 1)][(sym2__ - 1)], 0);}
+          } }
+      } 
+      current_statement__ = 99;
+      if (lcm_sym290__) {
+        current_statement__ = 99;
+        if (lcm_sym291__) {
+          current_statement__ = 99;
+          current_statement__ = 99;
+          check_less_or_equal(function__, "y[sym1__, sym2__]",
+                              rvalue(y,
+                                cons_list(index_uni(1),
+                                  cons_list(index_uni(1), nil_index_list())),
+                                "y"), 1);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 99;
+            current_statement__ = 99;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(1),
+                                    cons_list(index_uni(sym2__),
+                                      nil_index_list())), "y"), 1);}
+        } 
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 99;
+          if (lcm_sym291__) {
+            current_statement__ = 99;
+            current_statement__ = 99;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(sym1__),
+                                    cons_list(index_uni(1), nil_index_list())),
+                                  "y"), 1);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 99;
+              current_statement__ = 99;
+              check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                  y[(sym1__ - 1)][(sym2__ - 1)], 1);}
+          } }
+      } 
+      current_statement__ = 100;
+      if (lcm_sym290__) {
+        current_statement__ = 100;
+        current_statement__ = 100;
+        check_greater_or_equal(function__, "first[sym1__]",
+                               rvalue(first,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "first"), 0);
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 100;
+          current_statement__ = 100;
+          check_greater_or_equal(function__, "first[sym1__]",
+                                 first[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 100;
+      if (lcm_sym290__) {
+        current_statement__ = 100;
+        current_statement__ = 100;
+        check_less_or_equal(function__, "first[sym1__]",
+                            rvalue(first,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "first"), n_occasions);
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 100;
+          current_statement__ = 100;
+          check_less_or_equal(function__, "first[sym1__]",
+                              first[(sym1__ - 1)], n_occasions);}
+      } 
+      current_statement__ = 101;
+      if (lcm_sym290__) {
+        current_statement__ = 101;
+        current_statement__ = 101;
+        check_greater_or_equal(function__, "last[sym1__]",
+                               rvalue(last,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "last"), 0);
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 101;
+          current_statement__ = 101;
+          check_greater_or_equal(function__, "last[sym1__]",
+                                 last[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 101;
+      if (lcm_sym290__) {
+        current_statement__ = 101;
+        current_statement__ = 101;
+        check_less_or_equal(function__, "last[sym1__]",
+                            rvalue(last,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "last"), n_occasions);
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 101;
+          current_statement__ = 101;
+          check_less_or_equal(function__, "last[sym1__]", last[(sym1__ - 1)],
+                              n_occasions);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      current_statement__ = 4;
+      validate_non_negative_index("beta", "n_occasions", n_occasions);
+      num_params_r__ += n_occasions;
+      current_statement__ = 5;
+      validate_non_negative_index("epsilon", "M", M);
+      num_params_r__ += M;
+      num_params_r__ += 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "expr_prop_fail6_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      int lcm_sym289__;
+      int lcm_sym288__;
+      local_scalar_t__ lcm_sym287__;
+      int lcm_sym286__;
+      int lcm_sym285__;
+      int lcm_sym284__;
+      int lcm_sym283__;
+      double lcm_sym282__;
+      double lcm_sym280__;
+      int lcm_sym278__;
+      Eigen::Matrix<local_scalar_t__, -1, -1> lcm_sym277__;
+      double lcm_sym276__;
+      double lcm_sym275__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym274__;
+      double lcm_sym273__;
+      double lcm_sym272__;
+      double lcm_sym271__;
+      int lcm_sym270__;
+      double lcm_sym269__;
+      double lcm_sym268__;
+      double lcm_sym267__;
+      double lcm_sym266__;
+      double lcm_sym265__;
+      double lcm_sym264__;
+      double lcm_sym263__;
+      double lcm_sym262__;
+      double lcm_sym261__;
+      double lcm_sym260__;
+      double lcm_sym259__;
+      double lcm_sym258__;
+      double lcm_sym257__;
+      double lcm_sym256__;
+      int lcm_sym255__;
+      double lcm_sym254__;
+      int lcm_sym253__;
+      int lcm_sym252__;
+      double lcm_sym251__;
+      double lcm_sym250__;
+      double lcm_sym249__;
+      double lcm_sym248__;
+      double lcm_sym247__;
+      double lcm_sym246__;
+      double lcm_sym245__;
+      double lcm_sym244__;
+      double lcm_sym243__;
+      double lcm_sym242__;
+      double lcm_sym241__;
+      double lcm_sym240__;
+      double lcm_sym239__;
+      double lcm_sym238__;
+      int lcm_sym237__;
+      int lcm_sym236__;
+      double lcm_sym235__;
+      int lcm_sym234__;
+      int lcm_sym233__;
+      int lcm_sym232__;
+      int lcm_sym231__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym230__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym229__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym228__;
+      int lcm_sym227__;
+      int lcm_sym226__;
+      int lcm_sym225__;
+      int lcm_sym224__;
+      int lcm_sym223__;
+      int lcm_sym222__;
+      int lcm_sym221__;
+      int lcm_sym220__;
+      int lcm_sym219__;
+      int lcm_sym218__;
+      int lcm_sym217__;
+      int lcm_sym216__;
+      double lcm_sym215__;
+      double lcm_sym214__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym213__;
+      local_scalar_t__ mean_phi;
+      mean_phi = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      mean_phi = in__.scalar();
+      current_statement__ = 1;
+      if (jacobian__) {
+        current_statement__ = 1;
+        mean_phi = stan::math::lub_constrain(mean_phi, 0, 1, lp__);
+      } else {
+        current_statement__ = 1;
+        mean_phi = stan::math::lub_constrain(mean_phi, 0, 1);
+      }
+      local_scalar_t__ mean_p;
+      mean_p = DUMMY_VAR__;
+      
+      current_statement__ = 2;
+      mean_p = in__.scalar();
+      current_statement__ = 2;
+      if (jacobian__) {
+        current_statement__ = 2;
+        mean_p = stan::math::lub_constrain(mean_p, 0, 1, lp__);
+      } else {
+        current_statement__ = 2;
+        mean_p = stan::math::lub_constrain(mean_p, 0, 1);
+      }
+      local_scalar_t__ psi;
+      psi = DUMMY_VAR__;
+      
+      current_statement__ = 3;
+      psi = in__.scalar();
+      current_statement__ = 3;
+      if (jacobian__) {
+        current_statement__ = 3;
+        psi = stan::math::lub_constrain(psi, 0, 1, lp__);
+      } else {
+        current_statement__ = 3;
+        psi = stan::math::lub_constrain(psi, 0, 1);
+      }
+      current_statement__ = 4;
+      validate_non_negative_index("beta", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, 1> beta;
+      beta = Eigen::Matrix<local_scalar_t__, -1, 1>(n_occasions);
+      stan::math::fill(beta, DUMMY_VAR__);
+      
+      current_statement__ = 4;
+      beta = in__.vector(n_occasions);
+      lcm_sym218__ = logical_gte(n_occasions, 1);
+      if (lcm_sym218__) {
+        current_statement__ = 4;
+        if (jacobian__) {
+          current_statement__ = 4;
+          assign(beta, cons_list(index_uni(1), nil_index_list()),
+            stan::math::lb_constrain(
+              rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+              0, lp__), "assigning variable beta");
+        } else {
+          current_statement__ = 4;
+          assign(beta, cons_list(index_uni(1), nil_index_list()),
+            stan::math::lb_constrain(
+              rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+              0), "assigning variable beta");
+        }
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          current_statement__ = 4;
+          if (jacobian__) {
+            current_statement__ = 4;
+            assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+              stan::math::lb_constrain(beta[(sym1__ - 1)], 0, lp__),
+              "assigning variable beta");
+          } else {
+            current_statement__ = 4;
+            assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+              stan::math::lb_constrain(beta[(sym1__ - 1)], 0),
+              "assigning variable beta");
+          }}
+      } 
+      current_statement__ = 5;
+      validate_non_negative_index("epsilon", "M", M);
+      Eigen::Matrix<local_scalar_t__, -1, 1> epsilon;
+      epsilon = Eigen::Matrix<local_scalar_t__, -1, 1>(M);
+      stan::math::fill(epsilon, DUMMY_VAR__);
+      
+      current_statement__ = 5;
+      epsilon = in__.vector(M);
+      local_scalar_t__ sigma;
+      sigma = DUMMY_VAR__;
+      
+      current_statement__ = 6;
+      sigma = in__.scalar();
+      current_statement__ = 6;
+      if (jacobian__) {
+        current_statement__ = 6;
+        sigma = stan::math::lub_constrain(sigma, 0, 5, lp__);
+      } else {
+        current_statement__ = 6;
+        sigma = stan::math::lub_constrain(sigma, 0, 5);
+      }
+      current_statement__ = 7;
+      validate_non_negative_index("phi", "M", M);
+      lcm_sym227__ = (n_occasions - 1);
+      validate_non_negative_index("phi", "(n_occasions - 1)", lcm_sym227__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> phi;
+      phi = Eigen::Matrix<local_scalar_t__, -1, -1>(M, lcm_sym227__);
+      stan::math::fill(phi, DUMMY_VAR__);
+      
+      current_statement__ = 8;
+      validate_non_negative_index("p", "M", M);
+      current_statement__ = 8;
+      validate_non_negative_index("p", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> p;
+      p = Eigen::Matrix<local_scalar_t__, -1, -1>(M, n_occasions);
+      stan::math::fill(p, DUMMY_VAR__);
+      
+      current_statement__ = 9;
+      validate_non_negative_index("b", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, 1> b;
+      b = Eigen::Matrix<local_scalar_t__, -1, 1>(n_occasions);
+      stan::math::fill(b, DUMMY_VAR__);
+      
+      current_statement__ = 10;
+      validate_non_negative_index("nu", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, 1> nu;
+      nu = Eigen::Matrix<local_scalar_t__, -1, 1>(n_occasions);
+      stan::math::fill(nu, DUMMY_VAR__);
+      
+      current_statement__ = 11;
+      validate_non_negative_index("chi", "M", M);
+      current_statement__ = 11;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(M, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      assign(lcm_sym277__, nil_index_list(),
+        rep_matrix(mean_phi, M, lcm_sym227__),
+        "assigning variable lcm_sym277__");
+      assign(phi, nil_index_list(), lcm_sym277__, "assigning variable phi");
+      current_statement__ = 13;
+      if (lcm_sym218__) {
+        assign(lcm_sym274__, nil_index_list(),
+          inv_logit(add(logit(mean_p), epsilon)),
+          "assigning variable lcm_sym274__");
+        assign(p,
+          cons_list(index_omni(), cons_list(index_uni(1), nil_index_list())),
+          lcm_sym274__, "assigning variable p");
+        for (int t = 2; t <= n_occasions; ++t) {
+          current_statement__ = 12;
+          assign(p,
+            cons_list(index_omni(),
+              cons_list(index_uni(t), nil_index_list())), lcm_sym274__,
+            "assigning variable p");}
+      } 
+      assign(lcm_sym213__, nil_index_list(), divide(beta, sum(beta)),
+        "assigning variable lcm_sym213__");
+      assign(b, nil_index_list(), lcm_sym213__, "assigning variable b");
+      {
+        local_scalar_t__ cum_b;
+        cum_b = DUMMY_VAR__;
+        
+        lcm_sym287__ = rvalue(lcm_sym213__,
+                         cons_list(index_uni(1), nil_index_list()),
+                         "lcm_sym213__");
+        current_statement__ = 15;
+        assign(nu, cons_list(index_uni(1), nil_index_list()), lcm_sym287__,
+          "assigning variable nu");
+        current_statement__ = 19;
+        if (logical_gte(lcm_sym227__, 2)) {
+          current_statement__ = 16;
+          assign(nu, cons_list(index_uni(2), nil_index_list()),
+            (rvalue(lcm_sym213__, cons_list(index_uni(2), nil_index_list()),
+               "lcm_sym213__") / (1.0 - lcm_sym287__)),
+            "assigning variable nu");
+          current_statement__ = 17;
+          cum_b = (lcm_sym287__ +
+                    rvalue(lcm_sym213__,
+                      cons_list(index_uni(2), nil_index_list()),
+                      "lcm_sym213__"));
+          for (int t = 3; t <= lcm_sym227__; ++t) {
+            current_statement__ = 16;
+            assign(nu, cons_list(index_uni(t), nil_index_list()),
+              (rvalue(lcm_sym213__,
+                 cons_list(index_uni(t), nil_index_list()), "lcm_sym213__") /
+                (1.0 - cum_b)), "assigning variable nu");
+            current_statement__ = 17;
+            cum_b = (cum_b +
+                      rvalue(lcm_sym213__,
+                        cons_list(index_uni(t), nil_index_list()),
+                        "lcm_sym213__"));}
+        } 
+        current_statement__ = 20;
+        assign(nu, cons_list(index_uni(n_occasions), nil_index_list()), 1.0,
+          "assigning variable nu");
+      }
+      Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym15__;
+      int inline_sym23__;
+      inline_sym23__ = std::numeric_limits<int>::min();
+      
+      inline_sym23__ = 0;
+      for (int inline_sym24__ = 1; inline_sym24__ <= 1; ++inline_sym24__) {
+        int inline_sym16__;
+        inline_sym16__ = std::numeric_limits<int>::min();
+        
+        lcm_sym278__ = rows(p);
+        int inline_sym17__;
+        inline_sym17__ = std::numeric_limits<int>::min();
+        
+        lcm_sym270__ = cols(p);
+        current_statement__ = 24;
+        validate_non_negative_index("chi", "n_ind", lcm_sym278__);
+        current_statement__ = 24;
+        validate_non_negative_index("chi", "n_occasions", lcm_sym270__);
+        Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym18__;
+        inline_sym18__ = Eigen::Matrix<local_scalar_t__, -1, -1>(lcm_sym278__, lcm_sym270__);
+        stan::math::fill(inline_sym18__, DUMMY_VAR__);
+        
+        for (int inline_sym22__ = 1; inline_sym22__ <= lcm_sym278__;
+             ++inline_sym22__) {
+          current_statement__ = 25;
+          assign(inline_sym18__,
+            cons_list(index_uni(inline_sym22__),
+              cons_list(index_uni(lcm_sym270__), nil_index_list())), 1.0,
+            "assigning variable inline_sym18__");
+          lcm_sym232__ = (lcm_sym270__ - 1);
+          if (logical_gte(lcm_sym232__, 1)) {
+            int inline_sym19__;
+            inline_sym19__ = std::numeric_limits<int>::min();
+            
+            int inline_sym20__;
+            inline_sym20__ = std::numeric_limits<int>::min();
+            
+            lcm_sym237__ = (lcm_sym232__ + 1);
+            current_statement__ = 28;
+            assign(inline_sym18__,
+              cons_list(index_uni(inline_sym22__),
+                cons_list(index_uni(lcm_sym232__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(lcm_sym277__,
+                   cons_list(index_uni(inline_sym22__),
+                     cons_list(index_uni(lcm_sym232__), nil_index_list())),
+                   "lcm_sym277__") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(inline_sym22__),
+                        cons_list(index_uni(lcm_sym237__), nil_index_list())),
+                      "p"))),
+                rvalue(inline_sym18__,
+                  cons_list(index_uni(inline_sym22__),
+                    cons_list(index_uni(lcm_sym237__), nil_index_list())),
+                  "inline_sym18__"),
+                (1 -
+                  rvalue(lcm_sym277__,
+                    cons_list(index_uni(inline_sym22__),
+                      cons_list(index_uni(lcm_sym232__), nil_index_list())),
+                    "lcm_sym277__"))), "assigning variable inline_sym18__");
+            for (int inline_sym21__ = 2; inline_sym21__ <= lcm_sym232__;
+                 ++inline_sym21__) {
+              int inline_sym19__;
+              inline_sym19__ = std::numeric_limits<int>::min();
+              
+              lcm_sym231__ = (lcm_sym270__ - inline_sym21__);
+              int inline_sym20__;
+              inline_sym20__ = std::numeric_limits<int>::min();
+              
+              lcm_sym236__ = (lcm_sym231__ + 1);
+              current_statement__ = 28;
+              assign(inline_sym18__,
+                cons_list(index_uni(inline_sym22__),
+                  cons_list(index_uni(lcm_sym231__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(lcm_sym277__,
+                     cons_list(index_uni(inline_sym22__),
+                       cons_list(index_uni(lcm_sym231__), nil_index_list())),
+                     "lcm_sym277__") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(inline_sym22__),
+                          cons_list(index_uni(lcm_sym236__),
+                            nil_index_list())), "p"))),
+                  rvalue(inline_sym18__,
+                    cons_list(index_uni(inline_sym22__),
+                      cons_list(index_uni(lcm_sym236__), nil_index_list())),
+                    "inline_sym18__"),
+                  (1 -
+                    rvalue(lcm_sym277__,
+                      cons_list(index_uni(inline_sym22__),
+                        cons_list(index_uni(lcm_sym231__), nil_index_list())),
+                      "lcm_sym277__"))), "assigning variable inline_sym18__");
+            }
+          } 
+          if (inline_sym23__) {
+            break;
+          } }
+        if (inline_sym23__) {
+          break;
+        } 
+        inline_sym23__ = 1;
+        assign(inline_sym15__, nil_index_list(), inline_sym18__,
+          "assigning variable inline_sym15__");
+        break;}
+      assign(chi, nil_index_list(), inline_sym15__, "assigning variable chi");
+      current_statement__ = 7;
+      current_statement__ = 7;
+      check_greater_or_equal(function__, "phi", lcm_sym277__, 0);
+      current_statement__ = 7;
+      current_statement__ = 7;
+      check_less_or_equal(function__, "phi", lcm_sym277__, 1);
+      current_statement__ = 8;
+      current_statement__ = 8;
+      check_greater_or_equal(function__, "p", p, 0);
+      current_statement__ = 8;
+      current_statement__ = 8;
+      check_less_or_equal(function__, "p", p, 1);
+      current_statement__ = 9;
+      current_statement__ = 9;
+      check_simplex(function__, "b", lcm_sym213__);
+      current_statement__ = 10;
+      current_statement__ = 10;
+      check_greater_or_equal(function__, "nu", nu, 0);
+      current_statement__ = 10;
+      current_statement__ = 10;
+      check_less_or_equal(function__, "nu", nu, 1);
+      current_statement__ = 11;
+      current_statement__ = 11;
+      check_greater_or_equal(function__, "chi", inline_sym15__, 0);
+      current_statement__ = 11;
+      current_statement__ = 11;
+      check_less_or_equal(function__, "chi", inline_sym15__, 1);
+      {
+        current_statement__ = 70;
+        lp_accum__.add(normal_log<propto__>(epsilon, 0, sigma));
+        current_statement__ = 71;
+        lp_accum__.add(gamma_log<propto__>(beta, 1, 1));
+        int inline_sym32__;
+        inline_sym32__ = std::numeric_limits<int>::min();
+        
+        {
+          int inline_sym25__;
+          inline_sym25__ = std::numeric_limits<int>::min();
+          
+          lcm_sym288__ = rvalue(dims(y),
+                           cons_list(index_uni(1), nil_index_list()),
+                           "dims(y)");
+          int inline_sym26__;
+          inline_sym26__ = std::numeric_limits<int>::min();
+          
+          lcm_sym289__ = rvalue(dims(y),
+                           cons_list(index_uni(2), nil_index_list()),
+                           "dims(y)");
+          current_statement__ = 74;
+          validate_non_negative_index("qnu", "n_occasions", lcm_sym289__);
+          Eigen::Matrix<double, -1, 1> inline_sym27__;
+          inline_sym27__ = Eigen::Matrix<double, -1, 1>(lcm_sym289__);
+          stan::math::fill(inline_sym27__, std::numeric_limits<double>::quiet_NaN());
+          
+          assign(lcm_sym228__, nil_index_list(), subtract(1.0, nu),
+            "assigning variable lcm_sym228__");
+          lcm_sym225__ = logical_gte(lcm_sym288__, 1);
+          if (lcm_sym225__) {
+            current_statement__ = 75;
+            validate_non_negative_index("qp", "n_occasions", lcm_sym289__);
+            Eigen::Matrix<double, -1, 1> inline_sym28__;
+            inline_sym28__ = Eigen::Matrix<double, -1, 1>(lcm_sym289__);
+            stan::math::fill(inline_sym28__, std::numeric_limits<double>::quiet_NaN());
+            
+            assign(lcm_sym230__, nil_index_list(),
+              subtract(1.0,
+                transpose(
+                  rvalue(p, cons_list(index_uni(1), nil_index_list()), "p"))),
+              "assigning variable lcm_sym230__");
+            lcm_sym284__ = rvalue(first,
+                             cons_list(index_uni(1), nil_index_list()),
+                             "first");
+            if (lcm_sym284__) {
+              current_statement__ = 82;
+              lp_accum__.add(bernoulli_log<propto__>(1, psi));
+              current_statement__ = 90;
+              if (logical_eq(lcm_sym284__, 1)) {
+                current_statement__ = 88;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    (rvalue(nu, cons_list(index_uni(1), nil_index_list()),
+                       "nu") *
+                      rvalue(p,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(1), nil_index_list())), "p"))));
+              } else {
+                current_statement__ = 83;
+                validate_non_negative_index("lp",
+                                            "rvalue(first, cons_list(index_uni(i), nil_index_list()), \"first\")",
+                                            lcm_sym284__);
+                Eigen::Matrix<local_scalar_t__, -1, 1> inline_sym29__;
+                inline_sym29__ = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym284__);
+                stan::math::fill(inline_sym29__, DUMMY_VAR__);
+                
+                lcm_sym234__ = (lcm_sym284__ - 1);
+                assign(inline_sym29__,
+                  cons_list(index_uni(1), nil_index_list()),
+                  (((bernoulli_lpmf<false>(1,
+                       rvalue(nu, cons_list(index_uni(1), nil_index_list()),
+                         "nu")) +
+                      bernoulli_lpmf<false>(1,
+                        prod(
+                          rvalue(lcm_sym230__,
+                            cons_list(index_min_max(1, lcm_sym234__),
+                              nil_index_list()), "lcm_sym230__")))) +
+                     bernoulli_lpmf<false>(1,
+                       prod(
+                         rvalue(lcm_sym277__,
+                           cons_list(index_uni(1),
+                             cons_list(index_min_max(1, lcm_sym234__),
+                               nil_index_list())), "lcm_sym277__")))) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(p,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(lcm_sym284__),
+                            nil_index_list())), "p"))),
+                  "assigning variable inline_sym29__");
+                if (logical_gte(lcm_sym234__, 2)) {
+                  current_statement__ = 84;
+                  assign(inline_sym29__,
+                    cons_list(index_uni(2), nil_index_list()),
+                    ((((bernoulli_lpmf<false>(1,
+                          prod(
+                            rvalue(lcm_sym228__,
+                              cons_list(index_min_max(1, 1),
+                                nil_index_list()), "lcm_sym228__"))) +
+                         bernoulli_lpmf<false>(1,
+                           rvalue(nu,
+                             cons_list(index_uni(2), nil_index_list()), "nu")))
+                        +
+                        bernoulli_lpmf<false>(1,
+                          prod(
+                            rvalue(lcm_sym230__,
+                              cons_list(index_min_max(2, lcm_sym234__),
+                                nil_index_list()), "lcm_sym230__")))) +
+                       bernoulli_lpmf<false>(1,
+                         prod(
+                           rvalue(lcm_sym277__,
+                             cons_list(index_uni(1),
+                               cons_list(index_min_max(2, lcm_sym234__),
+                                 nil_index_list())), "lcm_sym277__")))) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(p,
+                          cons_list(index_uni(1),
+                            cons_list(index_uni(lcm_sym284__),
+                              nil_index_list())), "p"))),
+                    "assigning variable inline_sym29__");
+                  for (int inline_sym30__ = 3;
+                       inline_sym30__ <= lcm_sym234__; ++inline_sym30__) {
+                    current_statement__ = 84;
+                    assign(inline_sym29__,
+                      cons_list(index_uni(inline_sym30__), nil_index_list()),
+                      ((((bernoulli_lpmf<false>(1,
+                            prod(
+                              rvalue(lcm_sym228__,
+                                cons_list(
+                                  index_min_max(1, (inline_sym30__ - 1)),
+                                  nil_index_list()), "lcm_sym228__"))) +
+                           bernoulli_lpmf<false>(1, nu[(inline_sym30__ - 1)]))
+                          +
+                          bernoulli_lpmf<false>(1,
+                            prod(
+                              rvalue(lcm_sym230__,
+                                cons_list(
+                                  index_min_max(inline_sym30__, lcm_sym234__),
+                                  nil_index_list()), "lcm_sym230__")))) +
+                         bernoulli_lpmf<false>(1,
+                           prod(
+                             rvalue(lcm_sym277__,
+                               cons_list(index_uni(1),
+                                 cons_list(
+                                   index_min_max(inline_sym30__, lcm_sym234__),
+                                   nil_index_list())), "lcm_sym277__")))) +
+                        bernoulli_lpmf<false>(1,
+                          rvalue(p,
+                            cons_list(index_uni(1),
+                              cons_list(index_uni(lcm_sym284__),
+                                nil_index_list())), "p"))),
+                      "assigning variable inline_sym29__");}
+                } 
+                current_statement__ = 85;
+                assign(inline_sym29__,
+                  cons_list(index_uni(lcm_sym284__), nil_index_list()),
+                  ((bernoulli_lpmf<false>(1,
+                      prod(
+                        rvalue(lcm_sym228__,
+                          cons_list(index_min_max(1, lcm_sym234__),
+                            nil_index_list()), "lcm_sym228__"))) +
+                     bernoulli_lpmf<false>(1, nu[(lcm_sym284__ - 1)])) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(p,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(lcm_sym284__),
+                            nil_index_list())), "p"))),
+                  "assigning variable inline_sym29__");
+                current_statement__ = 86;
+                lp_accum__.add(log_sum_exp(inline_sym29__));
+              }
+              lcm_sym286__ = rvalue(last,
+                               cons_list(index_uni(1), nil_index_list()),
+                               "last");
+              if (logical_gte(lcm_sym286__, (lcm_sym284__ + 1))) {
+                current_statement__ = 91;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(lcm_sym277__,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(((lcm_sym284__ + 1) - 1)),
+                          nil_index_list())), "lcm_sym277__")));
+                lcm_sym253__ = ((lcm_sym284__ + 1) + 1);
+                lp_accum__.add(
+                  bernoulli_log<propto__>(
+                    rvalue(y,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((lcm_sym284__ + 1)),
+                          nil_index_list())), "y"),
+                    rvalue(p,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((lcm_sym284__ + 1)),
+                          nil_index_list())), "p")));
+                for (int inline_sym30__ = lcm_sym253__;
+                     inline_sym30__ <= lcm_sym286__; ++inline_sym30__) {
+                  current_statement__ = 91;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(1,
+                      rvalue(lcm_sym277__,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni((inline_sym30__ - 1)),
+                            nil_index_list())), "lcm_sym277__")));
+                  current_statement__ = 92;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(
+                      rvalue(y,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(inline_sym30__),
+                            nil_index_list())), "y"),
+                      rvalue(p,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(inline_sym30__),
+                            nil_index_list())), "p")));}
+              } 
+              current_statement__ = 94;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(inline_sym15__,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym286__), nil_index_list())),
+                    "inline_sym15__")));
+            } else {
+              lcm_sym255__ = (lcm_sym289__ + 1);
+              validate_non_negative_index("lp", "(n_occasions + 1)",
+                                          lcm_sym255__);
+              Eigen::Matrix<local_scalar_t__, -1, 1> inline_sym29__;
+              inline_sym29__ = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym255__);
+              stan::math::fill(inline_sym29__, DUMMY_VAR__);
+              
+              current_statement__ = 77;
+              assign(inline_sym29__,
+                cons_list(index_uni(1), nil_index_list()),
+                (((bernoulli_lpmf<false>(1, psi) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(nu, cons_list(index_uni(1), nil_index_list()),
+                        "nu"))) +
+                   bernoulli_lpmf<false>(0,
+                     rvalue(p,
+                       cons_list(index_uni(1),
+                         cons_list(index_uni(1), nil_index_list())), "p"))) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(inline_sym15__,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(1), nil_index_list())),
+                      "inline_sym15__"))),
+                "assigning variable inline_sym29__");
+              if (logical_gte(lcm_sym289__, 2)) {
+                current_statement__ = 78;
+                assign(inline_sym29__,
+                  cons_list(index_uni(2), nil_index_list()),
+                  ((((bernoulli_lpmf<false>(1, psi) +
+                       bernoulli_lpmf<false>(1,
+                         prod(
+                           rvalue(lcm_sym228__,
+                             cons_list(index_min_max(1, 1), nil_index_list()),
+                             "lcm_sym228__")))) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(nu, cons_list(index_uni(2), nil_index_list()),
+                          "nu"))) +
+                     bernoulli_lpmf<false>(0,
+                       rvalue(p,
+                         cons_list(index_uni(1),
+                           cons_list(index_uni(2), nil_index_list())), "p")))
+                    +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(inline_sym15__,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(2), nil_index_list())),
+                        "inline_sym15__"))),
+                  "assigning variable inline_sym29__");
+                for (int inline_sym30__ = 3; inline_sym30__ <= lcm_sym289__;
+                     ++inline_sym30__) {
+                  current_statement__ = 78;
+                  assign(inline_sym29__,
+                    cons_list(index_uni(inline_sym30__), nil_index_list()),
+                    ((((bernoulli_lpmf<false>(1, psi) +
+                         bernoulli_lpmf<false>(1,
+                           prod(
+                             rvalue(lcm_sym228__,
+                               cons_list(
+                                 index_min_max(1, (inline_sym30__ - 1)),
+                                 nil_index_list()), "lcm_sym228__")))) +
+                        bernoulli_lpmf<false>(1, nu[(inline_sym30__ - 1)])) +
+                       bernoulli_lpmf<false>(0,
+                         rvalue(p,
+                           cons_list(index_uni(1),
+                             cons_list(index_uni(inline_sym30__),
+                               nil_index_list())), "p"))) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(inline_sym15__,
+                          cons_list(index_uni(1),
+                            cons_list(index_uni(inline_sym30__),
+                              nil_index_list())), "inline_sym15__"))),
+                    "assigning variable inline_sym29__");}
+              } 
+              current_statement__ = 79;
+              assign(inline_sym29__,
+                cons_list(index_uni(lcm_sym255__), nil_index_list()),
+                bernoulli_lpmf<false>(0, psi),
+                "assigning variable inline_sym29__");
+              current_statement__ = 80;
+              lp_accum__.add(log_sum_exp(inline_sym29__));
+            }
+            for (int inline_sym31__ = 2; inline_sym31__ <= lcm_sym288__;
+                 ++inline_sym31__) {
+              current_statement__ = 75;
+              validate_non_negative_index("qp", "n_occasions", lcm_sym289__);
+              Eigen::Matrix<double, -1, 1> inline_sym28__;
+              inline_sym28__ = Eigen::Matrix<double, -1, 1>(lcm_sym289__);
+              stan::math::fill(inline_sym28__, std::numeric_limits<double>::quiet_NaN());
+              
+              assign(lcm_sym229__, nil_index_list(),
+                subtract(1.0,
+                  transpose(
+                    rvalue(p,
+                      cons_list(index_uni(inline_sym31__), nil_index_list()),
+                      "p"))), "assigning variable lcm_sym229__");
+              lcm_sym283__ = first[(inline_sym31__ - 1)];
+              if (lcm_sym283__) {
+                current_statement__ = 82;
+                lp_accum__.add(bernoulli_log<propto__>(1, psi));
+                current_statement__ = 90;
+                if (logical_eq(lcm_sym283__, 1)) {
+                  current_statement__ = 88;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(1,
+                      (rvalue(nu, cons_list(index_uni(1), nil_index_list()),
+                         "nu") *
+                        rvalue(p,
+                          cons_list(index_uni(inline_sym31__),
+                            cons_list(index_uni(1), nil_index_list())), "p"))));
+                } else {
+                  current_statement__ = 83;
+                  validate_non_negative_index("lp",
+                                              "rvalue(first, cons_list(index_uni(i), nil_index_list()), \"first\")",
+                                              lcm_sym283__);
+                  Eigen::Matrix<local_scalar_t__, -1, 1> inline_sym29__;
+                  inline_sym29__ = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym283__);
+                  stan::math::fill(inline_sym29__, DUMMY_VAR__);
+                  
+                  lcm_sym233__ = (lcm_sym283__ - 1);
+                  assign(inline_sym29__,
+                    cons_list(index_uni(1), nil_index_list()),
+                    (((bernoulli_lpmf<false>(1,
+                         rvalue(nu,
+                           cons_list(index_uni(1), nil_index_list()), "nu"))
+                        +
+                        bernoulli_lpmf<false>(1,
+                          prod(
+                            rvalue(lcm_sym229__,
+                              cons_list(index_min_max(1, lcm_sym233__),
+                                nil_index_list()), "lcm_sym229__")))) +
+                       bernoulli_lpmf<false>(1,
+                         prod(
+                           rvalue(lcm_sym277__,
+                             cons_list(index_uni(inline_sym31__),
+                               cons_list(index_min_max(1, lcm_sym233__),
+                                 nil_index_list())), "lcm_sym277__")))) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(p,
+                          cons_list(index_uni(inline_sym31__),
+                            cons_list(index_uni(lcm_sym283__),
+                              nil_index_list())), "p"))),
+                    "assigning variable inline_sym29__");
+                  if (logical_gte(lcm_sym233__, 2)) {
+                    current_statement__ = 84;
+                    assign(inline_sym29__,
+                      cons_list(index_uni(2), nil_index_list()),
+                      ((((bernoulli_lpmf<false>(1,
+                            prod(
+                              rvalue(lcm_sym228__,
+                                cons_list(index_min_max(1, 1),
+                                  nil_index_list()), "lcm_sym228__"))) +
+                           bernoulli_lpmf<false>(1,
+                             rvalue(nu,
+                               cons_list(index_uni(2), nil_index_list()),
+                               "nu"))) +
+                          bernoulli_lpmf<false>(1,
+                            prod(
+                              rvalue(lcm_sym229__,
+                                cons_list(index_min_max(2, lcm_sym233__),
+                                  nil_index_list()), "lcm_sym229__")))) +
+                         bernoulli_lpmf<false>(1,
+                           prod(
+                             rvalue(lcm_sym277__,
+                               cons_list(index_uni(inline_sym31__),
+                                 cons_list(index_min_max(2, lcm_sym233__),
+                                   nil_index_list())), "lcm_sym277__")))) +
+                        bernoulli_lpmf<false>(1,
+                          rvalue(p,
+                            cons_list(index_uni(inline_sym31__),
+                              cons_list(index_uni(lcm_sym283__),
+                                nil_index_list())), "p"))),
+                      "assigning variable inline_sym29__");
+                    for (int inline_sym30__ = 3;
+                         inline_sym30__ <= lcm_sym233__; ++inline_sym30__) {
+                      current_statement__ = 84;
+                      assign(inline_sym29__,
+                        cons_list(index_uni(inline_sym30__),
+                          nil_index_list()),
+                        ((((bernoulli_lpmf<false>(1,
+                              prod(
+                                rvalue(lcm_sym228__,
+                                  cons_list(
+                                    index_min_max(1, (inline_sym30__ - 1)),
+                                    nil_index_list()), "lcm_sym228__"))) +
+                             bernoulli_lpmf<false>(1,
+                               nu[(inline_sym30__ - 1)])) +
+                            bernoulli_lpmf<false>(1,
+                              prod(
+                                rvalue(lcm_sym229__,
+                                  cons_list(
+                                    index_min_max(inline_sym30__, lcm_sym233__),
+                                    nil_index_list()), "lcm_sym229__")))) +
+                           bernoulli_lpmf<false>(1,
+                             prod(
+                               rvalue(lcm_sym277__,
+                                 cons_list(index_uni(inline_sym31__),
+                                   cons_list(
+                                     index_min_max(inline_sym30__, lcm_sym233__),
+                                     nil_index_list())), "lcm_sym277__")))) +
+                          bernoulli_lpmf<false>(1,
+                            rvalue(p,
+                              cons_list(index_uni(inline_sym31__),
+                                cons_list(index_uni(lcm_sym283__),
+                                  nil_index_list())), "p"))),
+                        "assigning variable inline_sym29__");}
+                  } 
+                  current_statement__ = 85;
+                  assign(inline_sym29__,
+                    cons_list(index_uni(lcm_sym283__), nil_index_list()),
+                    ((bernoulli_lpmf<false>(1,
+                        prod(
+                          rvalue(lcm_sym228__,
+                            cons_list(index_min_max(1, lcm_sym233__),
+                              nil_index_list()), "lcm_sym228__"))) +
+                       bernoulli_lpmf<false>(1, nu[(lcm_sym283__ - 1)])) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(p,
+                          cons_list(index_uni(inline_sym31__),
+                            cons_list(index_uni(lcm_sym283__),
+                              nil_index_list())), "p"))),
+                    "assigning variable inline_sym29__");
+                  current_statement__ = 86;
+                  lp_accum__.add(log_sum_exp(inline_sym29__));
+                }
+                lcm_sym285__ = last[(inline_sym31__ - 1)];
+                if (logical_gte(lcm_sym285__, (lcm_sym283__ + 1))) {
+                  current_statement__ = 91;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(1,
+                      rvalue(lcm_sym277__,
+                        cons_list(index_uni(inline_sym31__),
+                          cons_list(index_uni(((lcm_sym283__ + 1) - 1)),
+                            nil_index_list())), "lcm_sym277__")));
+                  lcm_sym252__ = ((lcm_sym283__ + 1) + 1);
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(
+                      rvalue(y,
+                        cons_list(index_uni(inline_sym31__),
+                          cons_list(index_uni((lcm_sym283__ + 1)),
+                            nil_index_list())), "y"),
+                      rvalue(p,
+                        cons_list(index_uni(inline_sym31__),
+                          cons_list(index_uni((lcm_sym283__ + 1)),
+                            nil_index_list())), "p")));
+                  for (int inline_sym30__ = lcm_sym252__;
+                       inline_sym30__ <= lcm_sym285__; ++inline_sym30__) {
+                    current_statement__ = 91;
+                    lp_accum__.add(
+                      bernoulli_log<propto__>(1,
+                        rvalue(lcm_sym277__,
+                          cons_list(index_uni(inline_sym31__),
+                            cons_list(index_uni((inline_sym30__ - 1)),
+                              nil_index_list())), "lcm_sym277__")));
+                    current_statement__ = 92;
+                    lp_accum__.add(
+                      bernoulli_log<propto__>(
+                        y[(inline_sym31__ - 1)][(inline_sym30__ - 1)],
+                        rvalue(p,
+                          cons_list(index_uni(inline_sym31__),
+                            cons_list(index_uni(inline_sym30__),
+                              nil_index_list())), "p")));}
+                } 
+                current_statement__ = 94;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(inline_sym15__,
+                      cons_list(index_uni(inline_sym31__),
+                        cons_list(index_uni(lcm_sym285__), nil_index_list())),
+                      "inline_sym15__")));
+              } else {
+                lcm_sym255__ = (lcm_sym289__ + 1);
+                validate_non_negative_index("lp", "(n_occasions + 1)",
+                                            lcm_sym255__);
+                Eigen::Matrix<local_scalar_t__, -1, 1> inline_sym29__;
+                inline_sym29__ = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym255__);
+                stan::math::fill(inline_sym29__, DUMMY_VAR__);
+                
+                current_statement__ = 77;
+                assign(inline_sym29__,
+                  cons_list(index_uni(1), nil_index_list()),
+                  (((bernoulli_lpmf<false>(1, psi) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(nu, cons_list(index_uni(1), nil_index_list()),
+                          "nu"))) +
+                     bernoulli_lpmf<false>(0,
+                       rvalue(p,
+                         cons_list(index_uni(inline_sym31__),
+                           cons_list(index_uni(1), nil_index_list())), "p")))
+                    +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(inline_sym15__,
+                        cons_list(index_uni(inline_sym31__),
+                          cons_list(index_uni(1), nil_index_list())),
+                        "inline_sym15__"))),
+                  "assigning variable inline_sym29__");
+                if (logical_gte(lcm_sym289__, 2)) {
+                  current_statement__ = 78;
+                  assign(inline_sym29__,
+                    cons_list(index_uni(2), nil_index_list()),
+                    ((((bernoulli_lpmf<false>(1, psi) +
+                         bernoulli_lpmf<false>(1,
+                           prod(
+                             rvalue(lcm_sym228__,
+                               cons_list(index_min_max(1, 1),
+                                 nil_index_list()), "lcm_sym228__")))) +
+                        bernoulli_lpmf<false>(1,
+                          rvalue(nu,
+                            cons_list(index_uni(2), nil_index_list()), "nu")))
+                       +
+                       bernoulli_lpmf<false>(0,
+                         rvalue(p,
+                           cons_list(index_uni(inline_sym31__),
+                             cons_list(index_uni(2), nil_index_list())), "p")))
+                      +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(inline_sym15__,
+                          cons_list(index_uni(inline_sym31__),
+                            cons_list(index_uni(2), nil_index_list())),
+                          "inline_sym15__"))),
+                    "assigning variable inline_sym29__");
+                  for (int inline_sym30__ = 3;
+                       inline_sym30__ <= lcm_sym289__; ++inline_sym30__) {
+                    current_statement__ = 78;
+                    assign(inline_sym29__,
+                      cons_list(index_uni(inline_sym30__), nil_index_list()),
+                      ((((bernoulli_lpmf<false>(1, psi) +
+                           bernoulli_lpmf<false>(1,
+                             prod(
+                               rvalue(lcm_sym228__,
+                                 cons_list(
+                                   index_min_max(1, (inline_sym30__ - 1)),
+                                   nil_index_list()), "lcm_sym228__")))) +
+                          bernoulli_lpmf<false>(1, nu[(inline_sym30__ - 1)]))
+                         +
+                         bernoulli_lpmf<false>(0,
+                           rvalue(p,
+                             cons_list(index_uni(inline_sym31__),
+                               cons_list(index_uni(inline_sym30__),
+                                 nil_index_list())), "p"))) +
+                        bernoulli_lpmf<false>(1,
+                          rvalue(inline_sym15__,
+                            cons_list(index_uni(inline_sym31__),
+                              cons_list(index_uni(inline_sym30__),
+                                nil_index_list())), "inline_sym15__"))),
+                      "assigning variable inline_sym29__");}
+                } 
+                current_statement__ = 79;
+                assign(inline_sym29__,
+                  cons_list(index_uni(lcm_sym255__), nil_index_list()),
+                  bernoulli_lpmf<false>(0, psi),
+                  "assigning variable inline_sym29__");
+                current_statement__ = 80;
+                lp_accum__.add(log_sum_exp(inline_sym29__));
+              }}
+          } 
+        }
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "expr_prop_fail6_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      int lcm_sym212__;
+      int lcm_sym211__;
+      double lcm_sym210__;
+      double lcm_sym209__;
+      double lcm_sym208__;
+      double lcm_sym207__;
+      local_scalar_t__ lcm_sym206__;
+      double lcm_sym205__;
+      double lcm_sym204__;
+      int lcm_sym203__;
+      int lcm_sym202__;
+      int lcm_sym201__;
+      int lcm_sym200__;
+      int lcm_sym199__;
+      int lcm_sym198__;
+      int lcm_sym197__;
+      double lcm_sym196__;
+      double lcm_sym195__;
+      double lcm_sym194__;
+      double lcm_sym193__;
+      double lcm_sym158__;
+      double lcm_sym192__;
+      double lcm_sym191__;
+      double lcm_sym190__;
+      double lcm_sym189__;
+      double lcm_sym188__;
+      double lcm_sym187__;
+      double lcm_sym186__;
+      double lcm_sym185__;
+      double lcm_sym184__;
+      double lcm_sym183__;
+      int lcm_sym182__;
+      int lcm_sym181__;
+      int lcm_sym180__;
+      int lcm_sym179__;
+      int lcm_sym176__;
+      int lcm_sym175__;
+      int lcm_sym174__;
+      int lcm_sym173__;
+      int lcm_sym172__;
+      int lcm_sym171__;
+      int lcm_sym170__;
+      double lcm_sym169__;
+      int lcm_sym168__;
+      int lcm_sym167__;
+      int lcm_sym166__;
+      Eigen::Matrix<double, -1, -1> lcm_sym165__;
+      std::vector<int> lcm_sym164__;
+      std::vector<std::vector<int>> lcm_sym163__;
+      Eigen::Matrix<double, -1, 1> lcm_sym162__;
+      double lcm_sym157__;
+      double lcm_sym156__;
+      double lcm_sym155__;
+      double lcm_sym154__;
+      double lcm_sym161__;
+      double lcm_sym160__;
+      int lcm_sym159__;
+      int lcm_sym153__;
+      int lcm_sym152__;
+      int lcm_sym151__;
+      int lcm_sym150__;
+      double lcm_sym149__;
+      int lcm_sym148__;
+      int lcm_sym147__;
+      double lcm_sym146__;
+      int lcm_sym145__;
+      int lcm_sym144__;
+      int lcm_sym143__;
+      int lcm_sym142__;
+      int lcm_sym141__;
+      int lcm_sym140__;
+      int lcm_sym139__;
+      int lcm_sym138__;
+      int lcm_sym137__;
+      int lcm_sym136__;
+      int lcm_sym135__;
+      int lcm_sym134__;
+      int lcm_sym133__;
+      int lcm_sym132__;
+      double lcm_sym131__;
+      double lcm_sym130__;
+      Eigen::Matrix<double, -1, 1> lcm_sym129__;
+      double mean_phi;
+      mean_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mean_phi = in__.scalar();
+      current_statement__ = 1;
+      mean_phi = stan::math::lub_constrain(mean_phi, 0, 1);
+      double mean_p;
+      mean_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      mean_p = in__.scalar();
+      current_statement__ = 2;
+      mean_p = stan::math::lub_constrain(mean_p, 0, 1);
+      double psi;
+      psi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      psi = in__.scalar();
+      current_statement__ = 3;
+      psi = stan::math::lub_constrain(psi, 0, 1);
+      current_statement__ = 4;
+      validate_non_negative_index("beta", "n_occasions", n_occasions);
+      Eigen::Matrix<double, -1, 1> beta;
+      beta = Eigen::Matrix<double, -1, 1>(n_occasions);
+      stan::math::fill(beta, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 4;
+      beta = in__.vector(n_occasions);
+      lcm_sym133__ = logical_gte(n_occasions, 1);
+      if (lcm_sym133__) {
+        current_statement__ = 4;
+        assign(beta, cons_list(index_uni(1), nil_index_list()),
+          stan::math::lb_constrain(
+            rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+            0), "assigning variable beta");
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          current_statement__ = 4;
+          assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+            stan::math::lb_constrain(beta[(sym1__ - 1)], 0),
+            "assigning variable beta");}
+      } 
+      current_statement__ = 5;
+      validate_non_negative_index("epsilon", "M", M);
+      Eigen::Matrix<double, -1, 1> epsilon;
+      epsilon = Eigen::Matrix<double, -1, 1>(M);
+      stan::math::fill(epsilon, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 5;
+      epsilon = in__.vector(M);
+      double sigma;
+      sigma = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 6;
+      sigma = in__.scalar();
+      current_statement__ = 6;
+      sigma = stan::math::lub_constrain(sigma, 0, 5);
+      current_statement__ = 7;
+      validate_non_negative_index("phi", "M", M);
+      lcm_sym141__ = (n_occasions - 1);
+      validate_non_negative_index("phi", "(n_occasions - 1)", lcm_sym141__);
+      Eigen::Matrix<double, -1, -1> phi;
+      phi = Eigen::Matrix<double, -1, -1>(M, lcm_sym141__);
+      stan::math::fill(phi, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 8;
+      validate_non_negative_index("p", "M", M);
+      current_statement__ = 8;
+      validate_non_negative_index("p", "n_occasions", n_occasions);
+      Eigen::Matrix<double, -1, -1> p;
+      p = Eigen::Matrix<double, -1, -1>(M, n_occasions);
+      stan::math::fill(p, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 9;
+      validate_non_negative_index("b", "n_occasions", n_occasions);
+      Eigen::Matrix<double, -1, 1> b;
+      b = Eigen::Matrix<double, -1, 1>(n_occasions);
+      stan::math::fill(b, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 10;
+      validate_non_negative_index("nu", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, 1> nu;
+      nu = Eigen::Matrix<local_scalar_t__, -1, 1>(n_occasions);
+      stan::math::fill(nu, DUMMY_VAR__);
+      
+      current_statement__ = 11;
+      validate_non_negative_index("chi", "M", M);
+      current_statement__ = 11;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(M, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      vars__.push_back(mean_phi);
+      vars__.push_back(mean_p);
+      vars__.push_back(psi);
+      if (lcm_sym133__) {
+        vars__.push_back(
+          rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"));
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          vars__.push_back(beta[(sym1__ - 1)]);}
+      } 
+      lcm_sym132__ = logical_gte(M, 1);
+      if (lcm_sym132__) {
+        vars__.push_back(
+          rvalue(epsilon, cons_list(index_uni(1), nil_index_list()),
+            "epsilon"));
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          vars__.push_back(epsilon[(sym1__ - 1)]);}
+      } 
+      vars__.push_back(sigma);
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      assign(lcm_sym165__, nil_index_list(),
+        rep_matrix(mean_phi, M, lcm_sym141__),
+        "assigning variable lcm_sym165__");
+      assign(phi, nil_index_list(), lcm_sym165__, "assigning variable phi");
+      current_statement__ = 13;
+      if (lcm_sym133__) {
+        assign(lcm_sym162__, nil_index_list(),
+          inv_logit(add(logit(mean_p), epsilon)),
+          "assigning variable lcm_sym162__");
+        assign(p,
+          cons_list(index_omni(), cons_list(index_uni(1), nil_index_list())),
+          lcm_sym162__, "assigning variable p");
+        for (int t = 2; t <= n_occasions; ++t) {
+          current_statement__ = 12;
+          assign(p,
+            cons_list(index_omni(),
+              cons_list(index_uni(t), nil_index_list())), lcm_sym162__,
+            "assigning variable p");}
+      } 
+      assign(lcm_sym129__, nil_index_list(), divide(beta, sum(beta)),
+        "assigning variable lcm_sym129__");
+      assign(b, nil_index_list(), lcm_sym129__, "assigning variable b");
+      {
+        local_scalar_t__ cum_b;
+        cum_b = DUMMY_VAR__;
+        
+        lcm_sym206__ = rvalue(lcm_sym129__,
+                         cons_list(index_uni(1), nil_index_list()),
+                         "lcm_sym129__");
+        current_statement__ = 15;
+        assign(nu, cons_list(index_uni(1), nil_index_list()), lcm_sym206__,
+          "assigning variable nu");
+        current_statement__ = 19;
+        if (logical_gte(lcm_sym141__, 2)) {
+          current_statement__ = 16;
+          assign(nu, cons_list(index_uni(2), nil_index_list()),
+            (rvalue(lcm_sym129__, cons_list(index_uni(2), nil_index_list()),
+               "lcm_sym129__") / (1.0 - lcm_sym206__)),
+            "assigning variable nu");
+          current_statement__ = 17;
+          cum_b = (lcm_sym206__ +
+                    rvalue(lcm_sym129__,
+                      cons_list(index_uni(2), nil_index_list()),
+                      "lcm_sym129__"));
+          for (int t = 3; t <= lcm_sym141__; ++t) {
+            current_statement__ = 16;
+            assign(nu, cons_list(index_uni(t), nil_index_list()),
+              (rvalue(lcm_sym129__,
+                 cons_list(index_uni(t), nil_index_list()), "lcm_sym129__") /
+                (1.0 - cum_b)), "assigning variable nu");
+            current_statement__ = 17;
+            cum_b = (cum_b +
+                      rvalue(lcm_sym129__,
+                        cons_list(index_uni(t), nil_index_list()),
+                        "lcm_sym129__"));}
+        } 
+        current_statement__ = 20;
+        assign(nu, cons_list(index_uni(n_occasions), nil_index_list()), 1.0,
+          "assigning variable nu");
+      }
+      Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym1__;
+      int inline_sym9__;
+      inline_sym9__ = std::numeric_limits<int>::min();
+      
+      inline_sym9__ = 0;
+      for (int inline_sym10__ = 1; inline_sym10__ <= 1; ++inline_sym10__) {
+        int inline_sym2__;
+        inline_sym2__ = std::numeric_limits<int>::min();
+        
+        lcm_sym166__ = rows(p);
+        int inline_sym3__;
+        inline_sym3__ = std::numeric_limits<int>::min();
+        
+        lcm_sym159__ = cols(p);
+        current_statement__ = 24;
+        validate_non_negative_index("chi", "n_ind", lcm_sym166__);
+        current_statement__ = 24;
+        validate_non_negative_index("chi", "n_occasions", lcm_sym159__);
+        Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym4__;
+        inline_sym4__ = Eigen::Matrix<local_scalar_t__, -1, -1>(lcm_sym166__, lcm_sym159__);
+        stan::math::fill(inline_sym4__, DUMMY_VAR__);
+        
+        for (int inline_sym8__ = 1; inline_sym8__ <= lcm_sym166__;
+             ++inline_sym8__) {
+          current_statement__ = 25;
+          assign(inline_sym4__,
+            cons_list(index_uni(inline_sym8__),
+              cons_list(index_uni(lcm_sym159__), nil_index_list())), 1.0,
+            "assigning variable inline_sym4__");
+          lcm_sym143__ = (lcm_sym159__ - 1);
+          if (logical_gte(lcm_sym143__, 1)) {
+            int inline_sym5__;
+            inline_sym5__ = std::numeric_limits<int>::min();
+            
+            int inline_sym6__;
+            inline_sym6__ = std::numeric_limits<int>::min();
+            
+            lcm_sym148__ = (lcm_sym143__ + 1);
+            current_statement__ = 28;
+            assign(inline_sym4__,
+              cons_list(index_uni(inline_sym8__),
+                cons_list(index_uni(lcm_sym143__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(lcm_sym165__,
+                   cons_list(index_uni(inline_sym8__),
+                     cons_list(index_uni(lcm_sym143__), nil_index_list())),
+                   "lcm_sym165__") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(inline_sym8__),
+                        cons_list(index_uni(lcm_sym148__), nil_index_list())),
+                      "p"))),
+                rvalue(inline_sym4__,
+                  cons_list(index_uni(inline_sym8__),
+                    cons_list(index_uni(lcm_sym148__), nil_index_list())),
+                  "inline_sym4__"),
+                (1 -
+                  rvalue(lcm_sym165__,
+                    cons_list(index_uni(inline_sym8__),
+                      cons_list(index_uni(lcm_sym143__), nil_index_list())),
+                    "lcm_sym165__"))), "assigning variable inline_sym4__");
+            for (int inline_sym7__ = 2; inline_sym7__ <= lcm_sym143__;
+                 ++inline_sym7__) {
+              int inline_sym5__;
+              inline_sym5__ = std::numeric_limits<int>::min();
+              
+              lcm_sym142__ = (lcm_sym159__ - inline_sym7__);
+              int inline_sym6__;
+              inline_sym6__ = std::numeric_limits<int>::min();
+              
+              lcm_sym147__ = (lcm_sym142__ + 1);
+              current_statement__ = 28;
+              assign(inline_sym4__,
+                cons_list(index_uni(inline_sym8__),
+                  cons_list(index_uni(lcm_sym142__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(lcm_sym165__,
+                     cons_list(index_uni(inline_sym8__),
+                       cons_list(index_uni(lcm_sym142__), nil_index_list())),
+                     "lcm_sym165__") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(inline_sym8__),
+                          cons_list(index_uni(lcm_sym147__),
+                            nil_index_list())), "p"))),
+                  rvalue(inline_sym4__,
+                    cons_list(index_uni(inline_sym8__),
+                      cons_list(index_uni(lcm_sym147__), nil_index_list())),
+                    "inline_sym4__"),
+                  (1 -
+                    rvalue(lcm_sym165__,
+                      cons_list(index_uni(inline_sym8__),
+                        cons_list(index_uni(lcm_sym142__), nil_index_list())),
+                      "lcm_sym165__"))), "assigning variable inline_sym4__");
+            }
+          } 
+          if (inline_sym9__) {
+            break;
+          } }
+        if (inline_sym9__) {
+          break;
+        } 
+        inline_sym9__ = 1;
+        assign(inline_sym1__, nil_index_list(), inline_sym4__,
+          "assigning variable inline_sym1__");
+        break;}
+      assign(chi, nil_index_list(), inline_sym1__, "assigning variable chi");
+      if (logical_gte(lcm_sym141__, 1)) {
+        if (lcm_sym132__) {
+          vars__.push_back(
+            rvalue(lcm_sym165__,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "lcm_sym165__"));
+          for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+            vars__.push_back(
+              rvalue(lcm_sym165__,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "lcm_sym165__"));
+          }
+        } 
+        for (int sym1__ = 2; sym1__ <= lcm_sym141__; ++sym1__) {
+          if (lcm_sym132__) {
+            vars__.push_back(
+              rvalue(lcm_sym165__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                "lcm_sym165__"));
+            for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+              vars__.push_back(
+                rvalue(lcm_sym165__,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  "lcm_sym165__"));}
+          } }
+      } 
+      if (lcm_sym133__) {
+        if (lcm_sym132__) {
+          vars__.push_back(
+            rvalue(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "p"));
+          for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+            vars__.push_back(
+              rvalue(p,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "p"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          if (lcm_sym132__) {
+            vars__.push_back(
+              rvalue(p,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())), "p"));
+            for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+              vars__.push_back(
+                rvalue(p,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())), "p"));}
+          } }
+      } 
+      if (lcm_sym133__) {
+        vars__.push_back(
+          rvalue(lcm_sym129__, cons_list(index_uni(1), nil_index_list()),
+            "lcm_sym129__"));
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          vars__.push_back(lcm_sym129__[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym133__) {
+        vars__.push_back(
+          rvalue(nu, cons_list(index_uni(1), nil_index_list()), "nu"));
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          vars__.push_back(nu[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym133__) {
+        if (lcm_sym132__) {
+          vars__.push_back(
+            rvalue(inline_sym1__,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "inline_sym1__"));
+          for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+            vars__.push_back(
+              rvalue(inline_sym1__,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())),
+                "inline_sym1__"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          if (lcm_sym132__) {
+            vars__.push_back(
+              rvalue(inline_sym1__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                "inline_sym1__"));
+            for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+              vars__.push_back(
+                rvalue(inline_sym1__,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  "inline_sym1__"));}
+          } }
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+      double sigma2;
+      sigma2 = std::numeric_limits<double>::quiet_NaN();
+      
+      int Nsuper;
+      Nsuper = std::numeric_limits<int>::min();
+      
+      current_statement__ = 34;
+      validate_non_negative_index("N", "n_occasions", n_occasions);
+      std::vector<int> N;
+      N = std::vector<int>(n_occasions, std::numeric_limits<int>::min());
+      
+      current_statement__ = 35;
+      validate_non_negative_index("B", "n_occasions", n_occasions);
+      std::vector<int> B;
+      B = std::vector<int>(n_occasions, std::numeric_limits<int>::min());
+      
+      current_statement__ = 36;
+      validate_non_negative_index("z", "M", M);
+      current_statement__ = 36;
+      validate_non_negative_index("z", "n_occasions", n_occasions);
+      std::vector<std::vector<int>> z;
+      z = std::vector<std::vector<int>>(M, std::vector<int>(n_occasions, std::numeric_limits<int>::min()));
+      
+      lcm_sym169__ = square(sigma);
+      sigma2 = lcm_sym169__;
+      current_statement__ = 48;
+      if (lcm_sym132__) {
+        int q;
+        q = std::numeric_limits<int>::min();
+        
+        current_statement__ = 46;
+        if (bernoulli_rng(psi, base_rng__)) {
+          current_statement__ = 40;
+          assign(z,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())),
+            bernoulli_rng(
+              rvalue(nu, cons_list(index_uni(1), nil_index_list()), "nu"),
+              base_rng__), "assigning variable z");
+          current_statement__ = 44;
+          if (logical_gte(n_occasions, 2)) {
+            lcm_sym203__ = rvalue(z,
+                             cons_list(index_uni(1),
+                               cons_list(index_uni(1), nil_index_list())),
+                             "z");
+            lcm_sym153__ = (1 * (1 - lcm_sym203__));
+            q = lcm_sym153__;
+            current_statement__ = 41;
+            assign(z,
+              cons_list(index_uni(1),
+                cons_list(index_uni(2), nil_index_list())),
+              bernoulli_rng(
+                stan::math::fma(lcm_sym203__,
+                  rvalue(lcm_sym165__,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(1), nil_index_list())),
+                    "lcm_sym165__"),
+                  (lcm_sym153__ *
+                    rvalue(nu, cons_list(index_uni(2), nil_index_list()),
+                      "nu"))), base_rng__), "assigning variable z");
+            for (int t = 3; t <= n_occasions; ++t) {
+              current_statement__ = 42;
+              q = (q *
+                    (1 -
+                      rvalue(z,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni((t - 1)), nil_index_list())),
+                        "z")));
+              current_statement__ = 41;
+              assign(z,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(t), nil_index_list())),
+                bernoulli_rng(
+                  stan::math::fma(
+                    rvalue(z,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((t - 1)), nil_index_list())),
+                      "z"),
+                    rvalue(lcm_sym165__,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((t - 1)), nil_index_list())),
+                      "lcm_sym165__"),
+                    (q *
+                      rvalue(nu, cons_list(index_uni(t), nil_index_list()),
+                        "nu"))), base_rng__), "assigning variable z");}
+          } 
+        } else {
+          current_statement__ = 38;
+          assign(z,
+            cons_list(index_uni(1),
+              cons_list(index_omni(), nil_index_list())),
+            rep_array(0, n_occasions), "assigning variable z");
+        }
+        for (int i = 2; i <= M; ++i) {
+          int q;
+          q = std::numeric_limits<int>::min();
+          
+          current_statement__ = 46;
+          if (bernoulli_rng(psi, base_rng__)) {
+            current_statement__ = 40;
+            assign(z,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())),
+              bernoulli_rng(
+                rvalue(nu, cons_list(index_uni(1), nil_index_list()), "nu"),
+                base_rng__), "assigning variable z");
+            current_statement__ = 44;
+            if (logical_gte(n_occasions, 2)) {
+              lcm_sym152__ = (1 *
+                               (1 -
+                                 rvalue(z,
+                                   cons_list(index_uni(i),
+                                     cons_list(index_uni(1),
+                                       nil_index_list())), "z")));
+              q = lcm_sym152__;
+              current_statement__ = 41;
+              assign(z,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(2), nil_index_list())),
+                bernoulli_rng(
+                  stan::math::fma(
+                    rvalue(z,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(1), nil_index_list())), "z"),
+                    rvalue(lcm_sym165__,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(1), nil_index_list())),
+                      "lcm_sym165__"),
+                    (lcm_sym152__ *
+                      rvalue(nu, cons_list(index_uni(2), nil_index_list()),
+                        "nu"))), base_rng__), "assigning variable z");
+              for (int t = 3; t <= n_occasions; ++t) {
+                current_statement__ = 42;
+                q = (q *
+                      (1 -
+                        rvalue(z,
+                          cons_list(index_uni(i),
+                            cons_list(index_uni((t - 1)), nil_index_list())),
+                          "z")));
+                current_statement__ = 41;
+                assign(z,
+                  cons_list(index_uni(i),
+                    cons_list(index_uni(t), nil_index_list())),
+                  bernoulli_rng(
+                    stan::math::fma(
+                      rvalue(z,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((t - 1)), nil_index_list())),
+                        "z"),
+                      rvalue(lcm_sym165__,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((t - 1)), nil_index_list())),
+                        "lcm_sym165__"),
+                      (q *
+                        rvalue(nu, cons_list(index_uni(t), nil_index_list()),
+                          "nu"))), base_rng__), "assigning variable z");}
+            } 
+          } else {
+            current_statement__ = 38;
+            assign(z,
+              cons_list(index_uni(i),
+                cons_list(index_omni(), nil_index_list())),
+              rep_array(0, n_occasions), "assigning variable z");
+          }}
+      } 
+      {
+        current_statement__ = 49;
+        validate_non_negative_index("recruit", "M", M);
+        current_statement__ = 49;
+        validate_non_negative_index("recruit", "n_occasions", n_occasions);
+        std::vector<std::vector<int>> recruit;
+        recruit = std::vector<std::vector<int>>(M, std::vector<int>(n_occasions, std::numeric_limits<int>::min()));
+        
+        current_statement__ = 49;
+        assign(recruit, nil_index_list(), rep_array(0, M, n_occasions),
+          "assigning variable recruit");
+        current_statement__ = 50;
+        validate_non_negative_index("Nind", "M", M);
+        std::vector<int> Nind;
+        Nind = std::vector<int>(M, std::numeric_limits<int>::min());
+        
+        current_statement__ = 51;
+        validate_non_negative_index("Nalive", "M", M);
+        std::vector<int> Nalive;
+        Nalive = std::vector<int>(M, std::numeric_limits<int>::min());
+        
+        current_statement__ = 59;
+        if (lcm_sym132__) {
+          int f;
+          f = std::numeric_limits<int>::min();
+          
+          int inline_sym11__;
+          int inline_sym13__;
+          inline_sym13__ = std::numeric_limits<int>::min();
+          
+          inline_sym13__ = 0;
+          for (int inline_sym14__ = 1; inline_sym14__ <= 1; ++inline_sym14__) {
+            lcm_sym168__ = size(
+                             rvalue(z,
+                               cons_list(index_uni(1), nil_index_list()),
+                               "z"));
+            for (int inline_sym12__ = 1; inline_sym12__ <= lcm_sym168__;
+                 ++inline_sym12__) {
+              current_statement__ = 54;
+              if (rvalue(z,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(inline_sym12__), nil_index_list())),
+                    "z")) {
+                inline_sym13__ = 1;
+                inline_sym11__ = inline_sym12__;
+                break;
+              } }
+            if (inline_sym13__) {
+              break;
+            } 
+            inline_sym13__ = 1;
+            inline_sym11__ = 0;
+            break;}
+          current_statement__ = 57;
+          if (logical_gt(inline_sym11__, 0)) {
+            current_statement__ = 56;
+            assign(recruit,
+              cons_list(index_uni(1),
+                cons_list(index_uni(inline_sym11__), nil_index_list())), 1,
+              "assigning variable recruit");
+          } 
+          for (int i = 2; i <= M; ++i) {
+            int f;
+            f = std::numeric_limits<int>::min();
+            
+            int inline_sym11__;
+            int inline_sym13__;
+            inline_sym13__ = std::numeric_limits<int>::min();
+            
+            inline_sym13__ = 0;
+            for (int inline_sym14__ = 1; inline_sym14__ <= 1;
+                 ++inline_sym14__) {
+              lcm_sym167__ = size(
+                               rvalue(z,
+                                 cons_list(index_uni(i), nil_index_list()),
+                                 "z"));
+              for (int inline_sym12__ = 1; inline_sym12__ <= lcm_sym167__;
+                   ++inline_sym12__) {
+                current_statement__ = 54;
+                if (rvalue(z,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(inline_sym12__),
+                          nil_index_list())), "z")) {
+                  inline_sym13__ = 1;
+                  inline_sym11__ = inline_sym12__;
+                  break;
+                } }
+              if (inline_sym13__) {
+                break;
+              } 
+              inline_sym13__ = 1;
+              inline_sym11__ = 0;
+              break;}
+            current_statement__ = 57;
+            if (logical_gt(inline_sym11__, 0)) {
+              current_statement__ = 56;
+              assign(recruit,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(inline_sym11__), nil_index_list())), 1,
+                "assigning variable recruit");
+            } }
+        } 
+        current_statement__ = 63;
+        if (lcm_sym133__) {
+          current_statement__ = 60;
+          assign(N, cons_list(index_uni(1), nil_index_list()),
+            sum(
+              rvalue(z,
+                cons_list(index_omni(),
+                  cons_list(index_uni(1), nil_index_list())), "z")),
+            "assigning variable N");
+          current_statement__ = 61;
+          assign(B, cons_list(index_uni(1), nil_index_list()),
+            sum(
+              rvalue(recruit,
+                cons_list(index_omni(),
+                  cons_list(index_uni(1), nil_index_list())), "recruit")),
+            "assigning variable B");
+          for (int t = 2; t <= n_occasions; ++t) {
+            current_statement__ = 60;
+            assign(N, cons_list(index_uni(t), nil_index_list()),
+              sum(
+                rvalue(z,
+                  cons_list(index_omni(),
+                    cons_list(index_uni(t), nil_index_list())), "z")),
+              "assigning variable N");
+            current_statement__ = 61;
+            assign(B, cons_list(index_uni(t), nil_index_list()),
+              sum(
+                rvalue(recruit,
+                  cons_list(index_omni(),
+                    cons_list(index_uni(t), nil_index_list())), "recruit")),
+              "assigning variable B");}
+        } 
+        current_statement__ = 67;
+        if (lcm_sym132__) {
+          current_statement__ = 64;
+          assign(Nind, cons_list(index_uni(1), nil_index_list()),
+            sum(rvalue(z, cons_list(index_uni(1), nil_index_list()), "z")),
+            "assigning variable Nind");
+          current_statement__ = 65;
+          assign(Nalive, cons_list(index_uni(1), nil_index_list()),
+            logical_gt(
+              rvalue(Nind, cons_list(index_uni(1), nil_index_list()), "Nind"),
+              0), "assigning variable Nalive");
+          for (int i = 2; i <= M; ++i) {
+            current_statement__ = 64;
+            assign(Nind, cons_list(index_uni(i), nil_index_list()),
+              sum(rvalue(z, cons_list(index_uni(i), nil_index_list()), "z")),
+              "assigning variable Nind");
+            current_statement__ = 65;
+            assign(Nalive, cons_list(index_uni(i), nil_index_list()),
+              logical_gt(
+                rvalue(Nind, cons_list(index_uni(i), nil_index_list()),
+                  "Nind"), 0), "assigning variable Nalive");}
+        } 
+        current_statement__ = 68;
+        Nsuper = sum(Nalive);
+      }
+      current_statement__ = 32;
+      current_statement__ = 32;
+      check_greater_or_equal(function__, "sigma2", lcm_sym169__, 0);
+      current_statement__ = 33;
+      current_statement__ = 33;
+      check_greater_or_equal(function__, "Nsuper", Nsuper, 0);
+      current_statement__ = 34;
+      if (lcm_sym133__) {
+        current_statement__ = 34;
+        current_statement__ = 34;
+        check_greater_or_equal(function__, "N[sym1__]",
+                               rvalue(N,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "N"), 0);
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          current_statement__ = 34;
+          current_statement__ = 34;
+          check_greater_or_equal(function__, "N[sym1__]", N[(sym1__ - 1)], 0);
+        }
+      } 
+      current_statement__ = 35;
+      if (lcm_sym133__) {
+        current_statement__ = 35;
+        current_statement__ = 35;
+        check_greater_or_equal(function__, "B[sym1__]",
+                               rvalue(B,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "B"), 0);
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          current_statement__ = 35;
+          current_statement__ = 35;
+          check_greater_or_equal(function__, "B[sym1__]", B[(sym1__ - 1)], 0);
+        }
+      } 
+      current_statement__ = 36;
+      if (lcm_sym132__) {
+        current_statement__ = 36;
+        if (lcm_sym133__) {
+          current_statement__ = 36;
+          current_statement__ = 36;
+          check_greater_or_equal(function__, "z[sym1__, sym2__]",
+                                 rvalue(z,
+                                   cons_list(index_uni(1),
+                                     cons_list(index_uni(1),
+                                       nil_index_list())), "z"), 0);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 36;
+            current_statement__ = 36;
+            check_greater_or_equal(function__, "z[sym1__, sym2__]",
+                                   rvalue(z,
+                                     cons_list(index_uni(1),
+                                       cons_list(index_uni(sym2__),
+                                         nil_index_list())), "z"), 0);}
+        } 
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 36;
+          if (lcm_sym133__) {
+            current_statement__ = 36;
+            current_statement__ = 36;
+            check_greater_or_equal(function__, "z[sym1__, sym2__]",
+                                   rvalue(z,
+                                     cons_list(index_uni(sym1__),
+                                       cons_list(index_uni(1),
+                                         nil_index_list())), "z"), 0);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 36;
+              current_statement__ = 36;
+              check_greater_or_equal(function__, "z[sym1__, sym2__]",
+                                     z[(sym1__ - 1)][(sym2__ - 1)], 0);}
+          } }
+      } 
+      current_statement__ = 36;
+      if (lcm_sym132__) {
+        current_statement__ = 36;
+        if (lcm_sym133__) {
+          current_statement__ = 36;
+          current_statement__ = 36;
+          check_less_or_equal(function__, "z[sym1__, sym2__]",
+                              rvalue(z,
+                                cons_list(index_uni(1),
+                                  cons_list(index_uni(1), nil_index_list())),
+                                "z"), 1);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 36;
+            current_statement__ = 36;
+            check_less_or_equal(function__, "z[sym1__, sym2__]",
+                                rvalue(z,
+                                  cons_list(index_uni(1),
+                                    cons_list(index_uni(sym2__),
+                                      nil_index_list())), "z"), 1);}
+        } 
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 36;
+          if (lcm_sym133__) {
+            current_statement__ = 36;
+            current_statement__ = 36;
+            check_less_or_equal(function__, "z[sym1__, sym2__]",
+                                rvalue(z,
+                                  cons_list(index_uni(sym1__),
+                                    cons_list(index_uni(1), nil_index_list())),
+                                  "z"), 1);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 36;
+              current_statement__ = 36;
+              check_less_or_equal(function__, "z[sym1__, sym2__]",
+                                  z[(sym1__ - 1)][(sym2__ - 1)], 1);}
+          } }
+      } 
+      vars__.push_back(lcm_sym169__);
+      vars__.push_back(Nsuper);
+      if (lcm_sym133__) {
+        vars__.push_back(
+          rvalue(N, cons_list(index_uni(1), nil_index_list()), "N"));
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          vars__.push_back(N[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym133__) {
+        vars__.push_back(
+          rvalue(B, cons_list(index_uni(1), nil_index_list()), "B"));
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          vars__.push_back(B[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym133__) {
+        if (lcm_sym132__) {
+          vars__.push_back(
+            rvalue(z,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "z"));
+          for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+            vars__.push_back(
+              rvalue(z,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "z"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          if (lcm_sym132__) {
+            vars__.push_back(
+              rvalue(z,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())), "z"));
+            for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+              vars__.push_back(z[(sym2__ - 1)][(sym1__ - 1)]);}
+          } }
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym128__;
+      double lcm_sym127__;
+      double lcm_sym126__;
+      double lcm_sym125__;
+      double lcm_sym124__;
+      double lcm_sym123__;
+      double lcm_sym122__;
+      double lcm_sym121__;
+      int lcm_sym118__;
+      int lcm_sym117__;
+      int lcm_sym116__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double mean_phi;
+      mean_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mean_phi = context__.vals_r("mean_phi")[(1 - 1)];
+      current_statement__ = 1;
+      mean_phi = stan::math::lub_free(mean_phi, 0, 1);
+      double mean_p;
+      mean_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      mean_p = context__.vals_r("mean_p")[(1 - 1)];
+      current_statement__ = 2;
+      mean_p = stan::math::lub_free(mean_p, 0, 1);
+      double psi;
+      psi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      psi = context__.vals_r("psi")[(1 - 1)];
+      current_statement__ = 3;
+      psi = stan::math::lub_free(psi, 0, 1);
+      current_statement__ = 4;
+      validate_non_negative_index("beta", "n_occasions", n_occasions);
+      Eigen::Matrix<double, -1, 1> beta;
+      beta = Eigen::Matrix<double, -1, 1>(n_occasions);
+      stan::math::fill(beta, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> beta_flat__;
+        current_statement__ = 4;
+        assign(beta_flat__, nil_index_list(), context__.vals_r("beta"),
+          "assigning variable beta_flat__");
+        current_statement__ = 4;
+        pos__ = 1;
+        lcm_sym117__ = logical_gte(n_occasions, 1);
+        if (lcm_sym117__) {
+          current_statement__ = 4;
+          assign(beta, cons_list(index_uni(1), nil_index_list()),
+            rvalue(beta_flat__, cons_list(index_uni(1), nil_index_list()),
+              "beta_flat__"), "assigning variable beta");
+          current_statement__ = 4;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+            current_statement__ = 4;
+            assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+              beta_flat__[(pos__ - 1)], "assigning variable beta");
+            current_statement__ = 4;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 4;
+      if (lcm_sym117__) {
+        current_statement__ = 4;
+        assign(beta, cons_list(index_uni(1), nil_index_list()),
+          stan::math::lb_free(
+            rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+            0), "assigning variable beta");
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          current_statement__ = 4;
+          assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+            stan::math::lb_free(beta[(sym1__ - 1)], 0),
+            "assigning variable beta");}
+      } 
+      current_statement__ = 5;
+      validate_non_negative_index("epsilon", "M", M);
+      Eigen::Matrix<double, -1, 1> epsilon;
+      epsilon = Eigen::Matrix<double, -1, 1>(M);
+      stan::math::fill(epsilon, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> epsilon_flat__;
+        current_statement__ = 5;
+        assign(epsilon_flat__, nil_index_list(), context__.vals_r("epsilon"),
+          "assigning variable epsilon_flat__");
+        current_statement__ = 5;
+        pos__ = 1;
+        lcm_sym116__ = logical_gte(M, 1);
+        if (lcm_sym116__) {
+          current_statement__ = 5;
+          assign(epsilon, cons_list(index_uni(1), nil_index_list()),
+            rvalue(epsilon_flat__, cons_list(index_uni(1), nil_index_list()),
+              "epsilon_flat__"), "assigning variable epsilon");
+          current_statement__ = 5;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+            current_statement__ = 5;
+            assign(epsilon, cons_list(index_uni(sym1__), nil_index_list()),
+              epsilon_flat__[(pos__ - 1)], "assigning variable epsilon");
+            current_statement__ = 5;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      double sigma;
+      sigma = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 6;
+      sigma = context__.vals_r("sigma")[(1 - 1)];
+      current_statement__ = 6;
+      sigma = stan::math::lub_free(sigma, 0, 5);
+      vars__.push_back(mean_phi);
+      vars__.push_back(mean_p);
+      vars__.push_back(psi);
+      if (lcm_sym117__) {
+        vars__.push_back(
+          rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"));
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          vars__.push_back(beta[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym116__) {
+        vars__.push_back(
+          rvalue(epsilon, cons_list(index_uni(1), nil_index_list()),
+            "epsilon"));
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          vars__.push_back(epsilon[(sym1__ - 1)]);}
+      } 
+      vars__.push_back(sigma);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("mean_phi");
+    names__.push_back("mean_p");
+    names__.push_back("psi");
+    names__.push_back("beta");
+    names__.push_back("epsilon");
+    names__.push_back("sigma");
+    names__.push_back("phi");
+    names__.push_back("p");
+    names__.push_back("b");
+    names__.push_back("nu");
+    names__.push_back("chi");
+    names__.push_back("sigma2");
+    names__.push_back("Nsuper");
+    names__.push_back("N");
+    names__.push_back("B");
+    names__.push_back("z");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(M);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(M);
+    
+    dims__.push_back((n_occasions - 1));
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(M);
+    
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(M);
+    
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(M);
+    
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mean_phi");
+    param_names__.push_back(std::string() + "mean_p");
+    param_names__.push_back(std::string() + "psi");
+    for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+      {
+        param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym313__));
+      }}
+    for (int sym313__ = 1; sym313__ <= M; ++sym313__) {
+      {
+        param_names__.push_back(std::string() + "epsilon" + '.' + std::to_string(sym313__));
+      }}
+    param_names__.push_back(std::string() + "sigma");
+    if (emit_transformed_parameters__) {
+      for (int sym313__ = 1; sym313__ <= (n_occasions - 1); ++sym313__) {
+        {
+          for (int sym314__ = 1; sym314__ <= M; ++sym314__) {
+            {
+              param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym314__) + '.' + std::to_string(sym313__));
+            }}
+        }}
+      for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+        {
+          for (int sym314__ = 1; sym314__ <= M; ++sym314__) {
+            {
+              param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym314__) + '.' + std::to_string(sym313__));
+            }}
+        }}
+      for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+        {
+          param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym313__));
+        }}
+      for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+        {
+          param_names__.push_back(std::string() + "nu" + '.' + std::to_string(sym313__));
+        }}
+      for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+        {
+          for (int sym314__ = 1; sym314__ <= M; ++sym314__) {
+            {
+              param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym314__) + '.' + std::to_string(sym313__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      param_names__.push_back(std::string() + "sigma2");
+      param_names__.push_back(std::string() + "Nsuper");
+      for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+        {
+          param_names__.push_back(std::string() + "N" + '.' + std::to_string(sym313__));
+        }}
+      for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+        {
+          param_names__.push_back(std::string() + "B" + '.' + std::to_string(sym313__));
+        }}
+      for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+        {
+          for (int sym314__ = 1; sym314__ <= M; ++sym314__) {
+            {
+              param_names__.push_back(std::string() + "z" + '.' + std::to_string(sym314__) + '.' + std::to_string(sym313__));
+            }}
+        }}
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mean_phi");
+    param_names__.push_back(std::string() + "mean_p");
+    param_names__.push_back(std::string() + "psi");
+    for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+      {
+        param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym313__));
+      }}
+    for (int sym313__ = 1; sym313__ <= M; ++sym313__) {
+      {
+        param_names__.push_back(std::string() + "epsilon" + '.' + std::to_string(sym313__));
+      }}
+    param_names__.push_back(std::string() + "sigma");
+    if (emit_transformed_parameters__) {
+      for (int sym313__ = 1; sym313__ <= (n_occasions - 1); ++sym313__) {
+        {
+          for (int sym314__ = 1; sym314__ <= M; ++sym314__) {
+            {
+              param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym314__) + '.' + std::to_string(sym313__));
+            }}
+        }}
+      for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+        {
+          for (int sym314__ = 1; sym314__ <= M; ++sym314__) {
+            {
+              param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym314__) + '.' + std::to_string(sym313__));
+            }}
+        }}
+      for (int sym313__ = 1; sym313__ <= (n_occasions - 1); ++sym313__) {
+        {
+          param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym313__));
+        }}
+      for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+        {
+          param_names__.push_back(std::string() + "nu" + '.' + std::to_string(sym313__));
+        }}
+      for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+        {
+          for (int sym314__ = 1; sym314__ <= M; ++sym314__) {
+            {
+              param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym314__) + '.' + std::to_string(sym313__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      param_names__.push_back(std::string() + "sigma2");
+      param_names__.push_back(std::string() + "Nsuper");
+      for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+        {
+          param_names__.push_back(std::string() + "N" + '.' + std::to_string(sym313__));
+        }}
+      for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+        {
+          param_names__.push_back(std::string() + "B" + '.' + std::to_string(sym313__));
+        }}
+      for (int sym313__ = 1; sym313__ <= n_occasions; ++sym313__) {
+        {
+          for (int sym314__ = 1; sym314__ <= M; ++sym314__) {
+            {
+              param_names__.push_back(std::string() + "z" + '.' + std::to_string(sym314__) + '.' + std::to_string(sym313__));
+            }}
+        }}
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"psi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"parameters\"},{\"name\":\"epsilon\",\"type\":{\"name\":\"vector\",\"length\":" << M << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << (n_occasions - 1) << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"nu\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"Nsuper\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"},{\"name\":\"N\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"B\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"z\",\"type\":{\"name\":\"array\",\"length\":" << M << ",\"element_type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}}},\"block\":\"generated_quantities\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"psi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"parameters\"},{\"name\":\"epsilon\",\"type\":{\"name\":\"vector\",\"length\":" << M << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << (n_occasions - 1) << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" << (n_occasions - 1) << "},\"block\":\"transformed_parameters\"},{\"name\":\"nu\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"Nsuper\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"},{\"name\":\"N\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"B\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"z\",\"type\":{\"name\":\"array\",\"length\":" << M << ",\"element_type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}}},\"block\":\"generated_quantities\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef expr_prop_fail6_model_namespace::expr_prop_fail6_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail7.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace expr_prop_fail7_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'expr-prop-fail7.stan', line 20, column 2 to column 16)",
+                                                      " (in 'expr-prop-fail7.stan', line 21, column 2 to column 24)",
+                                                      " (in 'expr-prop-fail7.stan', line 40, column 2 to column 24)",
+                                                      " (in 'expr-prop-fail7.stan', line 42, column 4 to column 30)",
+                                                      " (in 'expr-prop-fail7.stan', line 44, column 6 to column 51)",
+                                                      " (in 'expr-prop-fail7.stan', line 43, column 4 to line 44, column 51)",
+                                                      " (in 'expr-prop-fail7.stan', line 45, column 4 to column 45)",
+                                                      " (in 'expr-prop-fail7.stan', line 41, column 17 to line 46, column 3)",
+                                                      " (in 'expr-prop-fail7.stan', line 25, column 2 to column 24)",
+                                                      " (in 'expr-prop-fail7.stan', line 28, column 6 to column 39)",
+                                                      " (in 'expr-prop-fail7.stan', line 27, column 4 to line 28, column 39)",
+                                                      " (in 'expr-prop-fail7.stan', line 26, column 2 to line 28, column 39)",
+                                                      " (in 'expr-prop-fail7.stan', line 32, column 4 to column 30)",
+                                                      " (in 'expr-prop-fail7.stan', line 34, column 6 to column 51)",
+                                                      " (in 'expr-prop-fail7.stan', line 33, column 4 to line 34, column 51)",
+                                                      " (in 'expr-prop-fail7.stan', line 35, column 4 to column 33)",
+                                                      " (in 'expr-prop-fail7.stan', line 31, column 17 to line 36, column 3)",
+                                                      " (in 'expr-prop-fail7.stan', line 31, column 2 to line 36, column 3)",
+                                                      " (in 'expr-prop-fail7.stan', line 12, column 2 to column 17)",
+                                                      " (in 'expr-prop-fail7.stan', line 13, column 2 to column 17)",
+                                                      " (in 'expr-prop-fail7.stan', line 14, column 2 to column 17)",
+                                                      " (in 'expr-prop-fail7.stan', line 15, column 2 to column 30)",
+                                                      " (in 'expr-prop-fail7.stan', line 16, column 2 to column 27)",
+                                                      " (in 'expr-prop-fail7.stan', line 17, column 2 to column 29)"};
+
+
+
+class expr_prop_fail7_model : public model_base_crtp<expr_prop_fail7_model> {
+
+ private:
+  int lcm_sym92__;
+  int lcm_sym91__;
+  int lcm_sym90__;
+  int lcm_sym89__;
+  int lcm_sym88__;
+  int lcm_sym87__;
+  double lcm_sym86__;
+  double lcm_sym85__;
+  Eigen::Matrix<double, -1, 1> lcm_sym84__;
+  Eigen::Matrix<double, -1, 1> lcm_sym83__;
+  double lcm_sym82__;
+  double lcm_sym81__;
+  int lcm_sym80__;
+  int lcm_sym79__;
+  int lcm_sym78__;
+  int lcm_sym77__;
+  int pos__;
+  int K;
+  int I;
+  int J;
+  std::vector<std::vector<int>> y;
+  Eigen::Matrix<double, -1, 1> alpha;
+  std::vector<Eigen::Matrix<double, -1, 1>> beta;
+ 
+ public:
+  ~expr_prop_fail7_model() { }
+  
+  std::string model_name() const { return "expr_prop_fail7_model"; }
+  
+  expr_prop_fail7_model(stan::io::var_context& context__,
+                        unsigned int random_seed__ = 0,
+                        std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "expr_prop_fail7_model_namespace::expr_prop_fail7_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","K","int",
+          context__.to_vec());
+      K = std::numeric_limits<int>::min();
+      
+      current_statement__ = 19;
+      K = context__.vals_i("K")[(1 - 1)];
+      context__.validate_dims("data initialization","I","int",
+          context__.to_vec());
+      I = std::numeric_limits<int>::min();
+      
+      current_statement__ = 20;
+      I = context__.vals_i("I")[(1 - 1)];
+      context__.validate_dims("data initialization","J","int",
+          context__.to_vec());
+      J = std::numeric_limits<int>::min();
+      
+      current_statement__ = 21;
+      J = context__.vals_i("J")[(1 - 1)];
+      current_statement__ = 22;
+      validate_non_negative_index("y", "I", I);
+      current_statement__ = 22;
+      validate_non_negative_index("y", "J", J);
+      context__.validate_dims("data initialization","y","int",
+          context__.to_vec(I, J));
+      y = std::vector<std::vector<int>>(I, std::vector<int>(J, std::numeric_limits<int>::min()));
+      
+      {
+        std::vector<int> y_flat__;
+        current_statement__ = 22;
+        assign(y_flat__, nil_index_list(), context__.vals_i("y"),
+          "assigning variable y_flat__");
+        current_statement__ = 22;
+        pos__ = 1;
+        lcm_sym78__ = logical_gte(J, 1);
+        if (lcm_sym78__) {
+          {
+            lcm_sym77__ = logical_gte(I, 1);
+            if (lcm_sym77__) {
+              current_statement__ = 22;
+              assign(y,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(1), nil_index_list())),
+                rvalue(y_flat__, cons_list(index_uni(1), nil_index_list()),
+                  "y_flat__"), "assigning variable y");
+              current_statement__ = 22;
+              pos__ = 2;
+              for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+                current_statement__ = 22;
+                assign(y,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(1), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 22;
+                pos__ = (pos__ + 1);}
+            } 
+            for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+              current_statement__ = 22;
+              if (lcm_sym77__) {
+                current_statement__ = 22;
+                assign(y,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 22;
+                pos__ = (pos__ + 1);
+                for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+                  current_statement__ = 22;
+                  assign(y,
+                    cons_list(index_uni(sym2__),
+                      cons_list(index_uni(sym1__), nil_index_list())),
+                    y_flat__[(pos__ - 1)], "assigning variable y");
+                  current_statement__ = 22;
+                  pos__ = (pos__ + 1);}
+              } }
+          }
+        } else {
+          lcm_sym77__ = logical_gte(I, 1);
+        }
+      }
+      current_statement__ = 23;
+      validate_non_negative_index("alpha", "K", K);
+      context__.validate_dims("data initialization","alpha","double",
+          context__.to_vec(K));
+      alpha = Eigen::Matrix<double, -1, 1>(K);
+      stan::math::fill(alpha, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> alpha_flat__;
+        current_statement__ = 23;
+        assign(alpha_flat__, nil_index_list(), context__.vals_r("alpha"),
+          "assigning variable alpha_flat__");
+        current_statement__ = 23;
+        pos__ = 1;
+        lcm_sym79__ = logical_gte(K, 1);
+        if (lcm_sym79__) {
+          current_statement__ = 23;
+          assign(alpha, cons_list(index_uni(1), nil_index_list()),
+            rvalue(alpha_flat__, cons_list(index_uni(1), nil_index_list()),
+              "alpha_flat__"), "assigning variable alpha");
+          current_statement__ = 23;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= K; ++sym1__) {
+            current_statement__ = 23;
+            assign(alpha, cons_list(index_uni(sym1__), nil_index_list()),
+              alpha_flat__[(pos__ - 1)], "assigning variable alpha");
+            current_statement__ = 23;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 24;
+      validate_non_negative_index("beta", "K", K);
+      current_statement__ = 24;
+      validate_non_negative_index("beta", "K", K);
+      context__.validate_dims("data initialization","beta","double",
+          context__.to_vec(K, K));
+      beta = std::vector<Eigen::Matrix<double, -1, 1>>(K, Eigen::Matrix<double, -1, 1>(K));
+      stan::math::fill(beta, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> beta_flat__;
+        current_statement__ = 24;
+        assign(beta_flat__, nil_index_list(), context__.vals_r("beta"),
+          "assigning variable beta_flat__");
+        current_statement__ = 24;
+        pos__ = 1;
+        current_statement__ = 24;
+        if (lcm_sym79__) {
+          current_statement__ = 24;
+          if (lcm_sym79__) {
+            current_statement__ = 24;
+            assign(beta,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())),
+              rvalue(beta_flat__, cons_list(index_uni(1), nil_index_list()),
+                "beta_flat__"), "assigning variable beta");
+            current_statement__ = 24;
+            pos__ = 2;
+            for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+              current_statement__ = 24;
+              assign(beta,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())),
+                beta_flat__[(pos__ - 1)], "assigning variable beta");
+              current_statement__ = 24;
+              pos__ = (pos__ + 1);}
+          } 
+          for (int sym1__ = 2; sym1__ <= K; ++sym1__) {
+            current_statement__ = 24;
+            if (lcm_sym79__) {
+              current_statement__ = 24;
+              assign(beta,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                beta_flat__[(pos__ - 1)], "assigning variable beta");
+              current_statement__ = 24;
+              pos__ = (pos__ + 1);
+              for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+                current_statement__ = 24;
+                assign(beta,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  beta_flat__[(pos__ - 1)], "assigning variable beta");
+                current_statement__ = 24;
+                pos__ = (pos__ + 1);}
+            } }
+        } 
+      }
+      current_statement__ = 19;
+      current_statement__ = 19;
+      check_greater_or_equal(function__, "K", K, 2);
+      current_statement__ = 20;
+      current_statement__ = 20;
+      check_greater_or_equal(function__, "I", I, 1);
+      current_statement__ = 21;
+      current_statement__ = 21;
+      check_greater_or_equal(function__, "J", J, 1);
+      current_statement__ = 22;
+      if (lcm_sym77__) {
+        current_statement__ = 22;
+        if (lcm_sym78__) {
+          current_statement__ = 22;
+          current_statement__ = 22;
+          check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                 rvalue(y,
+                                   cons_list(index_uni(1),
+                                     cons_list(index_uni(1),
+                                       nil_index_list())), "y"), 1);
+          for (int sym2__ = 2; sym2__ <= J; ++sym2__) {
+            current_statement__ = 22;
+            current_statement__ = 22;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(1),
+                                       cons_list(index_uni(sym2__),
+                                         nil_index_list())), "y"), 1);}
+        } 
+        for (int sym1__ = 2; sym1__ <= I; ++sym1__) {
+          current_statement__ = 22;
+          if (lcm_sym78__) {
+            current_statement__ = 22;
+            current_statement__ = 22;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(sym1__),
+                                       cons_list(index_uni(1),
+                                         nil_index_list())), "y"), 1);
+            for (int sym2__ = 2; sym2__ <= J; ++sym2__) {
+              current_statement__ = 22;
+              current_statement__ = 22;
+              check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                     y[(sym1__ - 1)][(sym2__ - 1)], 1);}
+          } }
+      } 
+      current_statement__ = 22;
+      if (lcm_sym77__) {
+        current_statement__ = 22;
+        if (lcm_sym78__) {
+          current_statement__ = 22;
+          current_statement__ = 22;
+          check_less_or_equal(function__, "y[sym1__, sym2__]",
+                              rvalue(y,
+                                cons_list(index_uni(1),
+                                  cons_list(index_uni(1), nil_index_list())),
+                                "y"), K);
+          for (int sym2__ = 2; sym2__ <= J; ++sym2__) {
+            current_statement__ = 22;
+            current_statement__ = 22;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(1),
+                                    cons_list(index_uni(sym2__),
+                                      nil_index_list())), "y"), K);}
+        } 
+        for (int sym1__ = 2; sym1__ <= I; ++sym1__) {
+          current_statement__ = 22;
+          if (lcm_sym78__) {
+            current_statement__ = 22;
+            current_statement__ = 22;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(sym1__),
+                                    cons_list(index_uni(1), nil_index_list())),
+                                  "y"), K);
+            for (int sym2__ = 2; sym2__ <= J; ++sym2__) {
+              current_statement__ = 22;
+              current_statement__ = 22;
+              check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                  y[(sym1__ - 1)][(sym2__ - 1)], K);}
+          } }
+      } 
+      current_statement__ = 23;
+      current_statement__ = 23;
+      check_greater_or_equal(function__, "alpha", alpha, 0);
+      current_statement__ = 24;
+      if (lcm_sym79__) {
+        current_statement__ = 24;
+        current_statement__ = 24;
+        check_greater_or_equal(function__, "beta[sym1__]",
+                               rvalue(beta,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "beta"), 0);
+        for (int sym1__ = 2; sym1__ <= K; ++sym1__) {
+          current_statement__ = 24;
+          current_statement__ = 24;
+          check_greater_or_equal(function__, "beta[sym1__]",
+                                 beta[(sym1__ - 1)], 0);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      current_statement__ = 1;
+      validate_positive_index("pi", "K", K);
+      num_params_r__ += (K - 1);
+      current_statement__ = 2;
+      validate_non_negative_index("theta", "J", J);
+      current_statement__ = 2;
+      validate_non_negative_index("theta", "K", K);
+      current_statement__ = 2;
+      validate_positive_index("theta", "K", K);
+      num_params_r__ += J * K * (K - 1);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "expr_prop_fail7_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      Eigen::Matrix<double, -1, 1> lcm_sym75__;
+      Eigen::Matrix<double, -1, 1> lcm_sym73__;
+      Eigen::Matrix<double, -1, 1> lcm_sym71__;
+      Eigen::Matrix<double, -1, 1> lcm_sym69__;
+      double lcm_sym67__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym66__;
+      double lcm_sym65__;
+      double lcm_sym64__;
+      double lcm_sym63__;
+      double lcm_sym62__;
+      double lcm_sym61__;
+      Eigen::Matrix<double, -1, 1> lcm_sym60__;
+      Eigen::Matrix<double, -1, 1> lcm_sym59__;
+      Eigen::Matrix<double, -1, 1> lcm_sym58__;
+      Eigen::Matrix<double, -1, 1> lcm_sym57__;
+      int lcm_sym76__;
+      int lcm_sym56__;
+      int lcm_sym55__;
+      int lcm_sym54__;
+      current_statement__ = 1;
+      validate_positive_index("pi", "K", K);
+      Eigen::Matrix<local_scalar_t__, -1, 1> pi;
+      pi = Eigen::Matrix<local_scalar_t__, -1, 1>(K);
+      stan::math::fill(pi, DUMMY_VAR__);
+      
+      Eigen::Matrix<local_scalar_t__, -1, 1> pi_in__;
+      pi_in__ = Eigen::Matrix<local_scalar_t__, -1, 1>((K - 1));
+      stan::math::fill(pi_in__, DUMMY_VAR__);
+      
+      lcm_sym76__ = (K - 1);
+      pi_in__ = in__.vector(lcm_sym76__);
+      current_statement__ = 1;
+      if (jacobian__) {
+        current_statement__ = 1;
+        assign(pi, nil_index_list(),
+          stan::math::simplex_constrain(pi_in__, lp__),
+          "assigning variable pi");
+      } else {
+        current_statement__ = 1;
+        assign(pi, nil_index_list(), stan::math::simplex_constrain(pi_in__),
+          "assigning variable pi");
+      }
+      current_statement__ = 2;
+      validate_non_negative_index("theta", "J", J);
+      current_statement__ = 2;
+      validate_non_negative_index("theta", "K", K);
+      current_statement__ = 2;
+      validate_positive_index("theta", "K", K);
+      std::vector<std::vector<Eigen::Matrix<local_scalar_t__, -1, 1>>> theta;
+      theta = std::vector<std::vector<Eigen::Matrix<local_scalar_t__, -1, 1>>>(J, std::vector<Eigen::Matrix<local_scalar_t__, -1, 1>>(K, Eigen::Matrix<local_scalar_t__, -1, 1>(K)));
+      stan::math::fill(theta, DUMMY_VAR__);
+      
+      std::vector<std::vector<Eigen::Matrix<local_scalar_t__, -1, 1>>> theta_in__;
+      theta_in__ = std::vector<std::vector<Eigen::Matrix<local_scalar_t__, -1, 1>>>(J, std::vector<Eigen::Matrix<local_scalar_t__, -1, 1>>(K, Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym76__)));
+      stan::math::fill(theta_in__, DUMMY_VAR__);
+      
+      lcm_sym55__ = logical_gte(J, 1);
+      if (lcm_sym55__) {
+        lcm_sym56__ = logical_gte(K, 1);
+        if (lcm_sym56__) {
+          current_statement__ = 2;
+          assign(theta_in__,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())),
+            in__.vector(lcm_sym76__), "assigning variable theta_in__");
+          for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+            current_statement__ = 2;
+            assign(theta_in__,
+              cons_list(index_uni(1),
+                cons_list(index_uni(sym2__), nil_index_list())),
+              in__.vector(lcm_sym76__), "assigning variable theta_in__");}
+        } 
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          current_statement__ = 2;
+          if (lcm_sym56__) {
+            current_statement__ = 2;
+            assign(theta_in__,
+              cons_list(index_uni(sym1__),
+                cons_list(index_uni(1), nil_index_list())),
+              in__.vector(lcm_sym76__), "assigning variable theta_in__");
+            for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+              current_statement__ = 2;
+              assign(theta_in__,
+                cons_list(index_uni(sym1__),
+                  cons_list(index_uni(sym2__), nil_index_list())),
+                in__.vector(lcm_sym76__), "assigning variable theta_in__");}
+          } }
+      } 
+      current_statement__ = 2;
+      if (lcm_sym55__) {
+        lcm_sym56__ = logical_gte(K, 1);
+        if (lcm_sym56__) {
+          current_statement__ = 2;
+          if (jacobian__) {
+            current_statement__ = 2;
+            assign(theta,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())),
+              stan::math::simplex_constrain(
+                rvalue(theta_in__,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(1), nil_index_list())), "theta_in__"),
+                lp__), "assigning variable theta");
+          } else {
+            current_statement__ = 2;
+            assign(theta,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())),
+              stan::math::simplex_constrain(
+                rvalue(theta_in__,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(1), nil_index_list())), "theta_in__")),
+              "assigning variable theta");
+          }
+          for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+            current_statement__ = 2;
+            if (jacobian__) {
+              current_statement__ = 2;
+              assign(theta,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym2__), nil_index_list())),
+                stan::math::simplex_constrain(
+                  rvalue(theta_in__,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(sym2__), nil_index_list())),
+                    "theta_in__"), lp__), "assigning variable theta");
+            } else {
+              current_statement__ = 2;
+              assign(theta,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym2__), nil_index_list())),
+                stan::math::simplex_constrain(
+                  rvalue(theta_in__,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(sym2__), nil_index_list())),
+                    "theta_in__")), "assigning variable theta");
+            }}
+        } 
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          current_statement__ = 2;
+          if (lcm_sym56__) {
+            current_statement__ = 2;
+            if (jacobian__) {
+              current_statement__ = 2;
+              assign(theta,
+                cons_list(index_uni(sym1__),
+                  cons_list(index_uni(1), nil_index_list())),
+                stan::math::simplex_constrain(
+                  rvalue(theta_in__,
+                    cons_list(index_uni(sym1__),
+                      cons_list(index_uni(1), nil_index_list())),
+                    "theta_in__"), lp__), "assigning variable theta");
+            } else {
+              current_statement__ = 2;
+              assign(theta,
+                cons_list(index_uni(sym1__),
+                  cons_list(index_uni(1), nil_index_list())),
+                stan::math::simplex_constrain(
+                  rvalue(theta_in__,
+                    cons_list(index_uni(sym1__),
+                      cons_list(index_uni(1), nil_index_list())),
+                    "theta_in__")), "assigning variable theta");
+            }
+            for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+              current_statement__ = 2;
+              if (jacobian__) {
+                current_statement__ = 2;
+                assign(theta,
+                  cons_list(index_uni(sym1__),
+                    cons_list(index_uni(sym2__), nil_index_list())),
+                  stan::math::simplex_constrain(
+                    theta_in__[(sym1__ - 1)][(sym2__ - 1)], lp__),
+                  "assigning variable theta");
+              } else {
+                current_statement__ = 2;
+                assign(theta,
+                  cons_list(index_uni(sym1__),
+                    cons_list(index_uni(sym2__), nil_index_list())),
+                  stan::math::simplex_constrain(
+                    theta_in__[(sym1__ - 1)][(sym2__ - 1)]),
+                  "assigning variable theta");
+              }}
+          } }
+      } 
+      {
+        current_statement__ = 9;
+        lp_accum__.add(dirichlet_log<propto__>(pi, alpha));
+        current_statement__ = 12;
+        if (lcm_sym55__) {
+          lcm_sym56__ = logical_gte(K, 1);
+          if (lcm_sym56__) {
+            current_statement__ = 10;
+            lp_accum__.add(
+              dirichlet_log<propto__>(
+                rvalue(theta,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(1), nil_index_list())), "theta"),
+                rvalue(beta, cons_list(index_uni(1), nil_index_list()),
+                  "beta")));
+            for (int k = 2; k <= K; ++k) {
+              current_statement__ = 10;
+              lp_accum__.add(
+                dirichlet_log<propto__>(
+                  rvalue(theta,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(k), nil_index_list())), "theta"),
+                  rvalue(beta, cons_list(index_uni(k), nil_index_list()),
+                    "beta")));}
+          } 
+          for (int j = 2; j <= J; ++j) {
+            current_statement__ = 11;
+            if (lcm_sym56__) {
+              current_statement__ = 10;
+              lp_accum__.add(
+                dirichlet_log<propto__>(
+                  rvalue(theta,
+                    cons_list(index_uni(j),
+                      cons_list(index_uni(1), nil_index_list())), "theta"),
+                  rvalue(beta, cons_list(index_uni(1), nil_index_list()),
+                    "beta")));
+              for (int k = 2; k <= K; ++k) {
+                current_statement__ = 10;
+                lp_accum__.add(
+                  dirichlet_log<propto__>(
+                    rvalue(theta,
+                      cons_list(index_uni(j),
+                        cons_list(index_uni(k), nil_index_list())), "theta"),
+                    rvalue(beta, cons_list(index_uni(k), nil_index_list()),
+                      "beta")));}
+            } }
+        } 
+        current_statement__ = 18;
+        if (logical_gte(I, 1)) {
+          current_statement__ = 13;
+          validate_non_negative_index("log_q", "K", K);
+          Eigen::Matrix<local_scalar_t__, -1, 1> log_q;
+          log_q = Eigen::Matrix<local_scalar_t__, -1, 1>(K);
+          stan::math::fill(log_q, DUMMY_VAR__);
+          
+          assign(lcm_sym66__, nil_index_list(), stan::math::log(pi),
+            "assigning variable lcm_sym66__");
+          assign(log_q, nil_index_list(), lcm_sym66__,
+            "assigning variable log_q");
+          current_statement__ = 15;
+          if (lcm_sym55__) {
+            current_statement__ = 14;
+            assign(log_q, nil_index_list(),
+              add(lcm_sym66__,
+                to_vector(
+                  stan::math::log(
+                    rvalue(theta,
+                      cons_list(index_uni(1),
+                        cons_list(index_omni(),
+                          cons_list(
+                            index_uni(rvalue(y,
+                                        cons_list(index_uni(1),
+                                          cons_list(index_uni(1),
+                                            nil_index_list())), "y")),
+                            nil_index_list()))), "theta")))),
+              "assigning variable log_q");
+            for (int j = 2; j <= J; ++j) {
+              current_statement__ = 14;
+              assign(log_q, nil_index_list(),
+                add(stan::model::deep_copy(log_q),
+                  to_vector(
+                    stan::math::log(
+                      rvalue(theta,
+                        cons_list(index_uni(j),
+                          cons_list(index_omni(),
+                            cons_list(
+                              index_uni(rvalue(y,
+                                          cons_list(index_uni(1),
+                                            cons_list(index_uni(j),
+                                              nil_index_list())), "y")),
+                              nil_index_list()))), "theta")))),
+                "assigning variable log_q");}
+          } 
+          current_statement__ = 16;
+          lp_accum__.add(log_sum_exp(log_q));
+          for (int i = 2; i <= I; ++i) {
+            current_statement__ = 13;
+            validate_non_negative_index("log_q", "K", K);
+            Eigen::Matrix<local_scalar_t__, -1, 1> log_q;
+            log_q = Eigen::Matrix<local_scalar_t__, -1, 1>(K);
+            stan::math::fill(log_q, DUMMY_VAR__);
+            
+            current_statement__ = 13;
+            assign(log_q, nil_index_list(), lcm_sym66__,
+              "assigning variable log_q");
+            current_statement__ = 15;
+            if (lcm_sym55__) {
+              current_statement__ = 14;
+              assign(log_q, nil_index_list(),
+                add(lcm_sym66__,
+                  to_vector(
+                    stan::math::log(
+                      rvalue(theta,
+                        cons_list(index_uni(1),
+                          cons_list(index_omni(),
+                            cons_list(
+                              index_uni(rvalue(y,
+                                          cons_list(index_uni(i),
+                                            cons_list(index_uni(1),
+                                              nil_index_list())), "y")),
+                              nil_index_list()))), "theta")))),
+                "assigning variable log_q");
+              for (int j = 2; j <= J; ++j) {
+                current_statement__ = 14;
+                assign(log_q, nil_index_list(),
+                  add(stan::model::deep_copy(log_q),
+                    to_vector(
+                      stan::math::log(
+                        rvalue(theta,
+                          cons_list(index_uni(j),
+                            cons_list(index_omni(),
+                              cons_list(
+                                index_uni(rvalue(y,
+                                            cons_list(index_uni(i),
+                                              cons_list(index_uni(j),
+                                                nil_index_list())), "y")),
+                                nil_index_list()))), "theta")))),
+                  "assigning variable log_q");}
+            } 
+            current_statement__ = 16;
+            lp_accum__.add(log_sum_exp(log_q));}
+        } 
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "expr_prop_fail7_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      Eigen::Matrix<double, -1, 1> lcm_sym38__;
+      Eigen::Matrix<double, -1, 1> lcm_sym37__;
+      Eigen::Matrix<double, -1, 1> lcm_sym36__;
+      Eigen::Matrix<double, -1, 1> lcm_sym35__;
+      double lcm_sym53__;
+      double lcm_sym52__;
+      double lcm_sym51__;
+      double lcm_sym50__;
+      double lcm_sym49__;
+      double lcm_sym48__;
+      double lcm_sym47__;
+      double lcm_sym46__;
+      double lcm_sym45__;
+      double lcm_sym44__;
+      double lcm_sym43__;
+      double lcm_sym42__;
+      double lcm_sym41__;
+      double lcm_sym40__;
+      Eigen::Matrix<double, -1, 1> lcm_sym34__;
+      Eigen::Matrix<double, -1, 1> lcm_sym33__;
+      Eigen::Matrix<double, -1, 1> lcm_sym32__;
+      Eigen::Matrix<double, -1, 1> lcm_sym31__;
+      Eigen::Matrix<double, -1, 1> lcm_sym30__;
+      int lcm_sym29__;
+      int lcm_sym28__;
+      Eigen::Matrix<double, -1, 1> lcm_sym27__;
+      int lcm_sym39__;
+      int lcm_sym26__;
+      int lcm_sym25__;
+      int lcm_sym24__;
+      current_statement__ = 1;
+      validate_positive_index("pi", "K", K);
+      Eigen::Matrix<double, -1, 1> pi;
+      pi = Eigen::Matrix<double, -1, 1>(K);
+      stan::math::fill(pi, std::numeric_limits<double>::quiet_NaN());
+      
+      Eigen::Matrix<double, -1, 1> pi_in__;
+      pi_in__ = Eigen::Matrix<double, -1, 1>((K - 1));
+      stan::math::fill(pi_in__, std::numeric_limits<double>::quiet_NaN());
+      
+      lcm_sym39__ = (K - 1);
+      pi_in__ = in__.vector(lcm_sym39__);
+      current_statement__ = 1;
+      assign(pi, nil_index_list(), stan::math::simplex_constrain(pi_in__),
+        "assigning variable pi");
+      current_statement__ = 2;
+      validate_non_negative_index("theta", "J", J);
+      current_statement__ = 2;
+      validate_non_negative_index("theta", "K", K);
+      current_statement__ = 2;
+      validate_positive_index("theta", "K", K);
+      std::vector<std::vector<Eigen::Matrix<double, -1, 1>>> theta;
+      theta = std::vector<std::vector<Eigen::Matrix<double, -1, 1>>>(J, std::vector<Eigen::Matrix<double, -1, 1>>(K, Eigen::Matrix<double, -1, 1>(K)));
+      stan::math::fill(theta, std::numeric_limits<double>::quiet_NaN());
+      
+      std::vector<std::vector<Eigen::Matrix<double, -1, 1>>> theta_in__;
+      theta_in__ = std::vector<std::vector<Eigen::Matrix<double, -1, 1>>>(J, std::vector<Eigen::Matrix<double, -1, 1>>(K, Eigen::Matrix<double, -1, 1>(lcm_sym39__)));
+      stan::math::fill(theta_in__, std::numeric_limits<double>::quiet_NaN());
+      
+      lcm_sym25__ = logical_gte(J, 1);
+      if (lcm_sym25__) {
+        {
+          lcm_sym26__ = logical_gte(K, 1);
+          if (lcm_sym26__) {
+            current_statement__ = 2;
+            assign(theta_in__,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())),
+              in__.vector(lcm_sym39__), "assigning variable theta_in__");
+            for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+              current_statement__ = 2;
+              assign(theta_in__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym2__), nil_index_list())),
+                in__.vector(lcm_sym39__), "assigning variable theta_in__");}
+          } 
+          for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+            current_statement__ = 2;
+            if (lcm_sym26__) {
+              current_statement__ = 2;
+              assign(theta_in__,
+                cons_list(index_uni(sym1__),
+                  cons_list(index_uni(1), nil_index_list())),
+                in__.vector(lcm_sym39__), "assigning variable theta_in__");
+              for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+                current_statement__ = 2;
+                assign(theta_in__,
+                  cons_list(index_uni(sym1__),
+                    cons_list(index_uni(sym2__), nil_index_list())),
+                  in__.vector(lcm_sym39__), "assigning variable theta_in__");
+              }
+            } }
+        }
+      } else {
+        lcm_sym26__ = logical_gte(K, 1);
+      }
+      current_statement__ = 2;
+      if (lcm_sym25__) {
+        current_statement__ = 2;
+        if (lcm_sym26__) {
+          current_statement__ = 2;
+          assign(theta,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())),
+            stan::math::simplex_constrain(
+              rvalue(theta_in__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(1), nil_index_list())), "theta_in__")),
+            "assigning variable theta");
+          for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+            current_statement__ = 2;
+            assign(theta,
+              cons_list(index_uni(1),
+                cons_list(index_uni(sym2__), nil_index_list())),
+              stan::math::simplex_constrain(
+                rvalue(theta_in__,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(sym2__), nil_index_list())),
+                  "theta_in__")), "assigning variable theta");}
+        } 
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          current_statement__ = 2;
+          if (lcm_sym26__) {
+            current_statement__ = 2;
+            assign(theta,
+              cons_list(index_uni(sym1__),
+                cons_list(index_uni(1), nil_index_list())),
+              stan::math::simplex_constrain(
+                rvalue(theta_in__,
+                  cons_list(index_uni(sym1__),
+                    cons_list(index_uni(1), nil_index_list())), "theta_in__")),
+              "assigning variable theta");
+            for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+              current_statement__ = 2;
+              assign(theta,
+                cons_list(index_uni(sym1__),
+                  cons_list(index_uni(sym2__), nil_index_list())),
+                stan::math::simplex_constrain(
+                  theta_in__[(sym1__ - 1)][(sym2__ - 1)]),
+                "assigning variable theta");}
+          } }
+      } 
+      if (lcm_sym26__) {
+        vars__.push_back(
+          rvalue(pi, cons_list(index_uni(1), nil_index_list()), "pi"));
+        for (int sym1__ = 2; sym1__ <= K; ++sym1__) {
+          vars__.push_back(pi[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym26__) {
+        if (lcm_sym26__) {
+          if (lcm_sym25__) {
+            vars__.push_back(
+              rvalue(theta,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(1), nil_index_list()))), "theta"));
+            for (int sym3__ = 2; sym3__ <= J; ++sym3__) {
+              vars__.push_back(
+                rvalue(theta,
+                  cons_list(index_uni(sym3__),
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(1), nil_index_list()))), "theta"));
+            }
+          } 
+          for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+            if (lcm_sym25__) {
+              vars__.push_back(
+                rvalue(theta,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(sym2__),
+                      cons_list(index_uni(1), nil_index_list()))), "theta"));
+              for (int sym3__ = 2; sym3__ <= J; ++sym3__) {
+                vars__.push_back(
+                  rvalue(theta,
+                    cons_list(index_uni(sym3__),
+                      cons_list(index_uni(sym2__),
+                        cons_list(index_uni(1), nil_index_list()))), "theta"));
+              }
+            } }
+        } 
+        for (int sym1__ = 2; sym1__ <= K; ++sym1__) {
+          if (lcm_sym26__) {
+            if (lcm_sym25__) {
+              vars__.push_back(
+                rvalue(theta,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(sym1__), nil_index_list()))),
+                  "theta"));
+              for (int sym3__ = 2; sym3__ <= J; ++sym3__) {
+                vars__.push_back(
+                  rvalue(theta,
+                    cons_list(index_uni(sym3__),
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(sym1__), nil_index_list()))),
+                    "theta"));}
+            } 
+            for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+              if (lcm_sym25__) {
+                vars__.push_back(
+                  rvalue(theta,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(sym2__),
+                        cons_list(index_uni(sym1__), nil_index_list()))),
+                    "theta"));
+                for (int sym3__ = 2; sym3__ <= J; ++sym3__) {
+                  vars__.push_back(
+                    theta[(sym3__ - 1)][(sym2__ - 1)][(sym1__ - 1)]);}
+              } }
+          } }
+      } 
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+      current_statement__ = 3;
+      validate_non_negative_index("log_Pr_z", "I", I);
+      current_statement__ = 3;
+      validate_non_negative_index("log_Pr_z", "K", K);
+      std::vector<Eigen::Matrix<local_scalar_t__, -1, 1>> log_Pr_z;
+      log_Pr_z = std::vector<Eigen::Matrix<local_scalar_t__, -1, 1>>(I, Eigen::Matrix<local_scalar_t__, -1, 1>(K));
+      stan::math::fill(log_Pr_z, DUMMY_VAR__);
+      
+      lcm_sym24__ = logical_gte(I, 1);
+      if (lcm_sym24__) {
+        current_statement__ = 4;
+        validate_non_negative_index("log_q", "K", K);
+        Eigen::Matrix<local_scalar_t__, -1, 1> log_q;
+        log_q = Eigen::Matrix<local_scalar_t__, -1, 1>(K);
+        stan::math::fill(log_q, DUMMY_VAR__);
+        
+        assign(lcm_sym34__, nil_index_list(), stan::math::log(pi),
+          "assigning variable lcm_sym34__");
+        assign(log_q, nil_index_list(), lcm_sym34__,
+          "assigning variable log_q");
+        current_statement__ = 6;
+        if (lcm_sym25__) {
+          current_statement__ = 5;
+          assign(log_q, nil_index_list(),
+            add(lcm_sym34__,
+              to_vector(
+                stan::math::log(
+                  rvalue(theta,
+                    cons_list(index_uni(1),
+                      cons_list(index_omni(),
+                        cons_list(
+                          index_uni(rvalue(y,
+                                      cons_list(index_uni(1),
+                                        cons_list(index_uni(1),
+                                          nil_index_list())), "y")),
+                          nil_index_list()))), "theta")))),
+            "assigning variable log_q");
+          for (int j = 2; j <= J; ++j) {
+            current_statement__ = 5;
+            assign(log_q, nil_index_list(),
+              add(stan::model::deep_copy(log_q),
+                to_vector(
+                  stan::math::log(
+                    rvalue(theta,
+                      cons_list(index_uni(j),
+                        cons_list(index_omni(),
+                          cons_list(
+                            index_uni(rvalue(y,
+                                        cons_list(index_uni(1),
+                                          cons_list(index_uni(j),
+                                            nil_index_list())), "y")),
+                            nil_index_list()))), "theta")))),
+              "assigning variable log_q");}
+        } 
+        current_statement__ = 7;
+        assign(log_Pr_z, cons_list(index_uni(1), nil_index_list()),
+          subtract(log_q, log_sum_exp(log_q)), "assigning variable log_Pr_z");
+        for (int i = 2; i <= I; ++i) {
+          current_statement__ = 4;
+          validate_non_negative_index("log_q", "K", K);
+          Eigen::Matrix<local_scalar_t__, -1, 1> log_q;
+          log_q = Eigen::Matrix<local_scalar_t__, -1, 1>(K);
+          stan::math::fill(log_q, DUMMY_VAR__);
+          
+          current_statement__ = 4;
+          assign(log_q, nil_index_list(), lcm_sym34__,
+            "assigning variable log_q");
+          current_statement__ = 6;
+          if (lcm_sym25__) {
+            current_statement__ = 5;
+            assign(log_q, nil_index_list(),
+              add(lcm_sym34__,
+                to_vector(
+                  stan::math::log(
+                    rvalue(theta,
+                      cons_list(index_uni(1),
+                        cons_list(index_omni(),
+                          cons_list(
+                            index_uni(rvalue(y,
+                                        cons_list(index_uni(i),
+                                          cons_list(index_uni(1),
+                                            nil_index_list())), "y")),
+                            nil_index_list()))), "theta")))),
+              "assigning variable log_q");
+            for (int j = 2; j <= J; ++j) {
+              current_statement__ = 5;
+              assign(log_q, nil_index_list(),
+                add(stan::model::deep_copy(log_q),
+                  to_vector(
+                    stan::math::log(
+                      rvalue(theta,
+                        cons_list(index_uni(j),
+                          cons_list(index_omni(),
+                            cons_list(
+                              index_uni(rvalue(y,
+                                          cons_list(index_uni(i),
+                                            cons_list(index_uni(j),
+                                              nil_index_list())), "y")),
+                              nil_index_list()))), "theta")))),
+                "assigning variable log_q");}
+          } 
+          current_statement__ = 7;
+          assign(log_Pr_z, cons_list(index_uni(i), nil_index_list()),
+            subtract(log_q, log_sum_exp(log_q)),
+            "assigning variable log_Pr_z");}
+      } 
+      if (lcm_sym26__) {
+        if (lcm_sym24__) {
+          vars__.push_back(
+            rvalue(log_Pr_z,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "log_Pr_z"));
+          for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+            vars__.push_back(
+              rvalue(log_Pr_z,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "log_Pr_z"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= K; ++sym1__) {
+          if (lcm_sym24__) {
+            vars__.push_back(
+              rvalue(log_Pr_z,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                "log_Pr_z"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              vars__.push_back(log_Pr_z[(sym2__ - 1)][(sym1__ - 1)]);}
+          } }
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym23__;
+      double lcm_sym22__;
+      double lcm_sym21__;
+      double lcm_sym20__;
+      Eigen::Matrix<double, -1, 1> lcm_sym9__;
+      double lcm_sym19__;
+      double lcm_sym18__;
+      Eigen::Matrix<double, -1, 1> lcm_sym8__;
+      double lcm_sym17__;
+      double lcm_sym16__;
+      double lcm_sym15__;
+      double lcm_sym14__;
+      Eigen::Matrix<double, -1, 1> lcm_sym7__;
+      Eigen::Matrix<double, -1, 1> lcm_sym6__;
+      double lcm_sym13__;
+      double lcm_sym12__;
+      double lcm_sym11__;
+      double lcm_sym10__;
+      int lcm_sym5__;
+      int lcm_sym4__;
+      int lcm_sym3__;
+      int lcm_sym2__;
+      int lcm_sym1__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      current_statement__ = 1;
+      validate_positive_index("pi", "K", K);
+      Eigen::Matrix<double, -1, 1> pi;
+      pi = Eigen::Matrix<double, -1, 1>(K);
+      stan::math::fill(pi, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> pi_flat__;
+        current_statement__ = 1;
+        assign(pi_flat__, nil_index_list(), context__.vals_r("pi"),
+          "assigning variable pi_flat__");
+        current_statement__ = 1;
+        pos__ = 1;
+        lcm_sym2__ = logical_gte(K, 1);
+        if (lcm_sym2__) {
+          current_statement__ = 1;
+          assign(pi, cons_list(index_uni(1), nil_index_list()),
+            rvalue(pi_flat__, cons_list(index_uni(1), nil_index_list()),
+              "pi_flat__"), "assigning variable pi");
+          current_statement__ = 1;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= K; ++sym1__) {
+            current_statement__ = 1;
+            assign(pi, cons_list(index_uni(sym1__), nil_index_list()),
+              pi_flat__[(pos__ - 1)], "assigning variable pi");
+            current_statement__ = 1;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 1;
+      assign(pi, nil_index_list(), stan::math::simplex_free(pi),
+        "assigning variable pi");
+      current_statement__ = 2;
+      validate_non_negative_index("theta", "J", J);
+      current_statement__ = 2;
+      validate_non_negative_index("theta", "K", K);
+      current_statement__ = 2;
+      validate_positive_index("theta", "K", K);
+      std::vector<std::vector<Eigen::Matrix<double, -1, 1>>> theta;
+      theta = std::vector<std::vector<Eigen::Matrix<double, -1, 1>>>(J, std::vector<Eigen::Matrix<double, -1, 1>>(K, Eigen::Matrix<double, -1, 1>(K)));
+      stan::math::fill(theta, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> theta_flat__;
+        current_statement__ = 2;
+        assign(theta_flat__, nil_index_list(), context__.vals_r("theta"),
+          "assigning variable theta_flat__");
+        current_statement__ = 2;
+        pos__ = 1;
+        current_statement__ = 2;
+        if (lcm_sym2__) {
+          {
+            current_statement__ = 2;
+            if (lcm_sym2__) {
+              {
+                lcm_sym1__ = logical_gte(J, 1);
+                if (lcm_sym1__) {
+                  current_statement__ = 2;
+                  assign(theta,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(1), nil_index_list()))),
+                    rvalue(theta_flat__,
+                      cons_list(index_uni(1), nil_index_list()),
+                      "theta_flat__"), "assigning variable theta");
+                  current_statement__ = 2;
+                  pos__ = 2;
+                  for (int sym3__ = 2; sym3__ <= J; ++sym3__) {
+                    current_statement__ = 2;
+                    assign(theta,
+                      cons_list(index_uni(sym3__),
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(1), nil_index_list()))),
+                      theta_flat__[(pos__ - 1)], "assigning variable theta");
+                    current_statement__ = 2;
+                    pos__ = (pos__ + 1);}
+                } 
+                for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+                  current_statement__ = 2;
+                  if (lcm_sym1__) {
+                    current_statement__ = 2;
+                    assign(theta,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(sym2__),
+                          cons_list(index_uni(1), nil_index_list()))),
+                      theta_flat__[(pos__ - 1)], "assigning variable theta");
+                    current_statement__ = 2;
+                    pos__ = (pos__ + 1);
+                    for (int sym3__ = 2; sym3__ <= J; ++sym3__) {
+                      current_statement__ = 2;
+                      assign(theta,
+                        cons_list(index_uni(sym3__),
+                          cons_list(index_uni(sym2__),
+                            cons_list(index_uni(1), nil_index_list()))),
+                        theta_flat__[(pos__ - 1)], "assigning variable theta");
+                      current_statement__ = 2;
+                      pos__ = (pos__ + 1);}
+                  } }
+              }
+            } else {
+              lcm_sym1__ = logical_gte(J, 1);
+            }
+            for (int sym1__ = 2; sym1__ <= K; ++sym1__) {
+              current_statement__ = 2;
+              if (lcm_sym2__) {
+                current_statement__ = 2;
+                if (lcm_sym1__) {
+                  current_statement__ = 2;
+                  assign(theta,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(sym1__), nil_index_list()))),
+                    theta_flat__[(pos__ - 1)], "assigning variable theta");
+                  current_statement__ = 2;
+                  pos__ = (pos__ + 1);
+                  for (int sym3__ = 2; sym3__ <= J; ++sym3__) {
+                    current_statement__ = 2;
+                    assign(theta,
+                      cons_list(index_uni(sym3__),
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(sym1__), nil_index_list()))),
+                      theta_flat__[(pos__ - 1)], "assigning variable theta");
+                    current_statement__ = 2;
+                    pos__ = (pos__ + 1);}
+                } 
+                for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+                  current_statement__ = 2;
+                  if (lcm_sym1__) {
+                    current_statement__ = 2;
+                    assign(theta,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(sym2__),
+                          cons_list(index_uni(sym1__), nil_index_list()))),
+                      theta_flat__[(pos__ - 1)], "assigning variable theta");
+                    current_statement__ = 2;
+                    pos__ = (pos__ + 1);
+                    for (int sym3__ = 2; sym3__ <= J; ++sym3__) {
+                      current_statement__ = 2;
+                      assign(theta,
+                        cons_list(index_uni(sym3__),
+                          cons_list(index_uni(sym2__),
+                            cons_list(index_uni(sym1__), nil_index_list()))),
+                        theta_flat__[(pos__ - 1)], "assigning variable theta");
+                      current_statement__ = 2;
+                      pos__ = (pos__ + 1);}
+                  } }
+              } }
+          }
+        } else {
+          lcm_sym1__ = logical_gte(J, 1);
+        }
+      }
+      current_statement__ = 2;
+      if (lcm_sym1__) {
+        current_statement__ = 2;
+        if (lcm_sym2__) {
+          current_statement__ = 2;
+          assign(theta,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())),
+            stan::math::simplex_free(
+              rvalue(theta,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(1), nil_index_list())), "theta")),
+            "assigning variable theta");
+          for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+            current_statement__ = 2;
+            assign(theta,
+              cons_list(index_uni(1),
+                cons_list(index_uni(sym2__), nil_index_list())),
+              stan::math::simplex_free(
+                rvalue(theta,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(sym2__), nil_index_list())), "theta")),
+              "assigning variable theta");}
+        } 
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          current_statement__ = 2;
+          if (lcm_sym2__) {
+            current_statement__ = 2;
+            assign(theta,
+              cons_list(index_uni(sym1__),
+                cons_list(index_uni(1), nil_index_list())),
+              stan::math::simplex_free(
+                rvalue(theta,
+                  cons_list(index_uni(sym1__),
+                    cons_list(index_uni(1), nil_index_list())), "theta")),
+              "assigning variable theta");
+            for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+              current_statement__ = 2;
+              assign(theta,
+                cons_list(index_uni(sym1__),
+                  cons_list(index_uni(sym2__), nil_index_list())),
+                stan::math::simplex_free(theta[(sym1__ - 1)][(sym2__ - 1)]),
+                "assigning variable theta");}
+          } }
+      } 
+      lcm_sym4__ = (K - 1);
+      lcm_sym3__ = logical_gte(lcm_sym4__, 1);
+      if (lcm_sym3__) {
+        vars__.push_back(
+          rvalue(pi, cons_list(index_uni(1), nil_index_list()), "pi"));
+        for (int sym1__ = 2; sym1__ <= lcm_sym4__; ++sym1__) {
+          vars__.push_back(pi[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym3__) {
+        if (lcm_sym2__) {
+          if (lcm_sym1__) {
+            vars__.push_back(
+              rvalue(theta,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(1), nil_index_list()))), "theta"));
+            for (int sym3__ = 2; sym3__ <= J; ++sym3__) {
+              vars__.push_back(
+                rvalue(theta,
+                  cons_list(index_uni(sym3__),
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(1), nil_index_list()))), "theta"));
+            }
+          } 
+          for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+            if (lcm_sym1__) {
+              vars__.push_back(
+                rvalue(theta,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(sym2__),
+                      cons_list(index_uni(1), nil_index_list()))), "theta"));
+              for (int sym3__ = 2; sym3__ <= J; ++sym3__) {
+                vars__.push_back(
+                  rvalue(theta,
+                    cons_list(index_uni(sym3__),
+                      cons_list(index_uni(sym2__),
+                        cons_list(index_uni(1), nil_index_list()))), "theta"));
+              }
+            } }
+        } 
+        for (int sym1__ = 2; sym1__ <= lcm_sym4__; ++sym1__) {
+          if (lcm_sym2__) {
+            if (lcm_sym1__) {
+              vars__.push_back(
+                rvalue(theta,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(sym1__), nil_index_list()))),
+                  "theta"));
+              for (int sym3__ = 2; sym3__ <= J; ++sym3__) {
+                vars__.push_back(
+                  rvalue(theta,
+                    cons_list(index_uni(sym3__),
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(sym1__), nil_index_list()))),
+                    "theta"));}
+            } 
+            for (int sym2__ = 2; sym2__ <= K; ++sym2__) {
+              if (lcm_sym1__) {
+                vars__.push_back(
+                  rvalue(theta,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(sym2__),
+                        cons_list(index_uni(sym1__), nil_index_list()))),
+                    "theta"));
+                for (int sym3__ = 2; sym3__ <= J; ++sym3__) {
+                  vars__.push_back(
+                    theta[(sym3__ - 1)][(sym2__ - 1)][(sym1__ - 1)]);}
+              } }
+          } }
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("pi");
+    names__.push_back("theta");
+    names__.push_back("log_Pr_z");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dims__.push_back(K);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(J);
+    
+    dims__.push_back(K);
+    
+    dims__.push_back(K);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(I);
+    
+    dims__.push_back(K);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    for (int sym93__ = 1; sym93__ <= K; ++sym93__) {
+      {
+        param_names__.push_back(std::string() + "pi" + '.' + std::to_string(sym93__));
+      }}
+    for (int sym93__ = 1; sym93__ <= K; ++sym93__) {
+      {
+        for (int sym94__ = 1; sym94__ <= K; ++sym94__) {
+          {
+            for (int sym95__ = 1; sym95__ <= J; ++sym95__) {
+              {
+                param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym95__) + '.' + std::to_string(sym94__) + '.' + std::to_string(sym93__));
+              }}
+          }}
+      }}
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      for (int sym93__ = 1; sym93__ <= K; ++sym93__) {
+        {
+          for (int sym94__ = 1; sym94__ <= I; ++sym94__) {
+            {
+              param_names__.push_back(std::string() + "log_Pr_z" + '.' + std::to_string(sym94__) + '.' + std::to_string(sym93__));
+            }}
+        }}
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    for (int sym93__ = 1; sym93__ <= (K - 1); ++sym93__) {
+      {
+        param_names__.push_back(std::string() + "pi" + '.' + std::to_string(sym93__));
+      }}
+    for (int sym93__ = 1; sym93__ <= (K - 1); ++sym93__) {
+      {
+        for (int sym94__ = 1; sym94__ <= K; ++sym94__) {
+          {
+            for (int sym95__ = 1; sym95__ <= J; ++sym95__) {
+              {
+                param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym95__) + '.' + std::to_string(sym94__) + '.' + std::to_string(sym93__));
+              }}
+          }}
+      }}
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      for (int sym93__ = 1; sym93__ <= K; ++sym93__) {
+        {
+          for (int sym94__ = 1; sym94__ <= I; ++sym94__) {
+            {
+              param_names__.push_back(std::string() + "log_Pr_z" + '.' + std::to_string(sym94__) + '.' + std::to_string(sym93__));
+            }}
+        }}
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"pi\",\"type\":{\"name\":\"vector\",\"length\":" << K << "},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << J << ",\"element_type\":{\"name\":\"array\",\"length\":" << K << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}}},\"block\":\"parameters\"},{\"name\":\"log_Pr_z\",\"type\":{\"name\":\"array\",\"length\":" << I << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"pi\",\"type\":{\"name\":\"vector\",\"length\":" << (K - 1) << "},\"block\":\"parameters\"},{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << J << ",\"element_type\":{\"name\":\"array\",\"length\":" << K << ",\"element_type\":{\"name\":\"vector\",\"length\":" << (K - 1) << "}}},\"block\":\"parameters\"},{\"name\":\"log_Pr_z\",\"type\":{\"name\":\"array\",\"length\":" << I << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"generated_quantities\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef expr_prop_fail7_model_namespace::expr_prop_fail7_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp expr-prop-fail8.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace expr_prop_fail8_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'expr-prop-fail8.stan', line 11, column 2 to column 13)",
+                                                      " (in 'expr-prop-fail8.stan', line 12, column 2 to column 13)",
+                                                      " (in 'expr-prop-fail8.stan', line 14, column 2 to column 26)",
+                                                      " (in 'expr-prop-fail8.stan', line 15, column 2 to column 24)",
+                                                      " (in 'expr-prop-fail8.stan', line 17, column 2 to column 22)",
+                                                      " (in 'expr-prop-fail8.stan', line 18, column 2 to column 24)",
+                                                      " (in 'expr-prop-fail8.stan', line 21, column 2 to column 47)",
+                                                      " (in 'expr-prop-fail8.stan', line 22, column 2 to column 16)",
+                                                      " (in 'expr-prop-fail8.stan', line 23, column 2 to column 25)",
+                                                      " (in 'expr-prop-fail8.stan', line 24, column 2 to column 24)",
+                                                      " (in 'expr-prop-fail8.stan', line 27, column 2 to column 33)",
+                                                      " (in 'expr-prop-fail8.stan', line 2, column 2 to column 17)",
+                                                      " (in 'expr-prop-fail8.stan', line 3, column 2 to column 23)",
+                                                      " (in 'expr-prop-fail8.stan', line 4, column 2 to column 39)",
+                                                      " (in 'expr-prop-fail8.stan', line 5, column 2 to column 39)",
+                                                      " (in 'expr-prop-fail8.stan', line 7, column 2 to column 20)",
+                                                      " (in 'expr-prop-fail8.stan', line 8, column 2 to column 14)"};
+
+
+
+class expr_prop_fail8_model : public model_base_crtp<expr_prop_fail8_model> {
+
+ private:
+  int lcm_sym35__;
+  int lcm_sym34__;
+  double lcm_sym33__;
+  double lcm_sym32__;
+  int lcm_sym31__;
+  int lcm_sym30__;
+  int lcm_sym29__;
+  int lcm_sym28__;
+  int lcm_sym27__;
+  int lcm_sym26__;
+  int lcm_sym25__;
+  int pos__;
+  int N;
+  int N_edges;
+  std::vector<int> node1;
+  std::vector<int> node2;
+  std::vector<int> y;
+  Eigen::Matrix<double, -1, 1> x;
+ 
+ public:
+  ~expr_prop_fail8_model() { }
+  
+  std::string model_name() const { return "expr_prop_fail8_model"; }
+  
+  expr_prop_fail8_model(stan::io::var_context& context__,
+                        unsigned int random_seed__ = 0,
+                        std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "expr_prop_fail8_model_namespace::expr_prop_fail8_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","N","int",
+          context__.to_vec());
+      N = std::numeric_limits<int>::min();
+      
+      current_statement__ = 12;
+      N = context__.vals_i("N")[(1 - 1)];
+      context__.validate_dims("data initialization","N_edges","int",
+          context__.to_vec());
+      N_edges = std::numeric_limits<int>::min();
+      
+      current_statement__ = 13;
+      N_edges = context__.vals_i("N_edges")[(1 - 1)];
+      current_statement__ = 14;
+      validate_non_negative_index("node1", "N_edges", N_edges);
+      context__.validate_dims("data initialization","node1","int",
+          context__.to_vec(N_edges));
+      node1 = std::vector<int>(N_edges, std::numeric_limits<int>::min());
+      
+      current_statement__ = 14;
+      assign(node1, nil_index_list(), context__.vals_i("node1"),
+        "assigning variable node1");
+      current_statement__ = 15;
+      validate_non_negative_index("node2", "N_edges", N_edges);
+      context__.validate_dims("data initialization","node2","int",
+          context__.to_vec(N_edges));
+      node2 = std::vector<int>(N_edges, std::numeric_limits<int>::min());
+      
+      current_statement__ = 15;
+      assign(node2, nil_index_list(), context__.vals_i("node2"),
+        "assigning variable node2");
+      current_statement__ = 16;
+      validate_non_negative_index("y", "N", N);
+      context__.validate_dims("data initialization","y","int",
+          context__.to_vec(N));
+      y = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 16;
+      assign(y, nil_index_list(), context__.vals_i("y"),
+        "assigning variable y");
+      current_statement__ = 17;
+      validate_non_negative_index("x", "N", N);
+      context__.validate_dims("data initialization","x","double",
+          context__.to_vec(N));
+      x = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(x, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> x_flat__;
+        current_statement__ = 17;
+        assign(x_flat__, nil_index_list(), context__.vals_r("x"),
+          "assigning variable x_flat__");
+        current_statement__ = 17;
+        pos__ = 1;
+        lcm_sym25__ = logical_gte(N, 1);
+        if (lcm_sym25__) {
+          current_statement__ = 17;
+          assign(x, cons_list(index_uni(1), nil_index_list()),
+            rvalue(x_flat__, cons_list(index_uni(1), nil_index_list()),
+              "x_flat__"), "assigning variable x");
+          current_statement__ = 17;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 17;
+            assign(x, cons_list(index_uni(sym1__), nil_index_list()),
+              x_flat__[(pos__ - 1)], "assigning variable x");
+            current_statement__ = 17;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 12;
+      current_statement__ = 12;
+      check_greater_or_equal(function__, "N", N, 0);
+      current_statement__ = 13;
+      current_statement__ = 13;
+      check_greater_or_equal(function__, "N_edges", N_edges, 0);
+      lcm_sym26__ = logical_gte(N_edges, 1);
+      if (lcm_sym26__) {
+        current_statement__ = 14;
+        current_statement__ = 14;
+        check_greater_or_equal(function__, "node1[sym1__]",
+                               rvalue(node1,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "node1"), 1);
+        for (int sym1__ = 2; sym1__ <= N_edges; ++sym1__) {
+          current_statement__ = 14;
+          current_statement__ = 14;
+          check_greater_or_equal(function__, "node1[sym1__]",
+                                 node1[(sym1__ - 1)], 1);}
+      } 
+      current_statement__ = 14;
+      if (lcm_sym26__) {
+        current_statement__ = 14;
+        current_statement__ = 14;
+        check_less_or_equal(function__, "node1[sym1__]",
+                            rvalue(node1,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "node1"), N);
+        for (int sym1__ = 2; sym1__ <= N_edges; ++sym1__) {
+          current_statement__ = 14;
+          current_statement__ = 14;
+          check_less_or_equal(function__, "node1[sym1__]",
+                              node1[(sym1__ - 1)], N);}
+      } 
+      current_statement__ = 15;
+      if (lcm_sym26__) {
+        current_statement__ = 15;
+        current_statement__ = 15;
+        check_greater_or_equal(function__, "node2[sym1__]",
+                               rvalue(node2,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "node2"), 1);
+        for (int sym1__ = 2; sym1__ <= N_edges; ++sym1__) {
+          current_statement__ = 15;
+          current_statement__ = 15;
+          check_greater_or_equal(function__, "node2[sym1__]",
+                                 node2[(sym1__ - 1)], 1);}
+      } 
+      current_statement__ = 15;
+      if (lcm_sym26__) {
+        current_statement__ = 15;
+        current_statement__ = 15;
+        check_less_or_equal(function__, "node2[sym1__]",
+                            rvalue(node2,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "node2"), N);
+        for (int sym1__ = 2; sym1__ <= N_edges; ++sym1__) {
+          current_statement__ = 15;
+          current_statement__ = 15;
+          check_less_or_equal(function__, "node2[sym1__]",
+                              node2[(sym1__ - 1)], N);}
+      } 
+      current_statement__ = 16;
+      if (lcm_sym25__) {
+        current_statement__ = 16;
+        current_statement__ = 16;
+        check_greater_or_equal(function__, "y[sym1__]",
+                               rvalue(y,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "y"), 0);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 16;
+          current_statement__ = 16;
+          check_greater_or_equal(function__, "y[sym1__]", y[(sym1__ - 1)], 0);
+        }
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      current_statement__ = 5;
+      validate_non_negative_index("theta_std", "N", N);
+      num_params_r__ += N;
+      current_statement__ = 6;
+      validate_non_negative_index("phi_std_raw", "N", N);
+      num_params_r__ += N;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "expr_prop_fail8_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      local_scalar_t__ lcm_sym24__;
+      double lcm_sym23__;
+      Eigen::Matrix<double, -1, 1> lcm_sym22__;
+      local_scalar_t__ beta0;
+      beta0 = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      beta0 = in__.scalar();
+      local_scalar_t__ beta1;
+      beta1 = DUMMY_VAR__;
+      
+      current_statement__ = 2;
+      beta1 = in__.scalar();
+      local_scalar_t__ tau_theta;
+      tau_theta = DUMMY_VAR__;
+      
+      current_statement__ = 3;
+      tau_theta = in__.scalar();
+      current_statement__ = 3;
+      if (jacobian__) {
+        current_statement__ = 3;
+        tau_theta = stan::math::lb_constrain(tau_theta, 0, lp__);
+      } else {
+        current_statement__ = 3;
+        tau_theta = stan::math::lb_constrain(tau_theta, 0);
+      }
+      local_scalar_t__ tau_phi;
+      tau_phi = DUMMY_VAR__;
+      
+      current_statement__ = 4;
+      tau_phi = in__.scalar();
+      current_statement__ = 4;
+      if (jacobian__) {
+        current_statement__ = 4;
+        tau_phi = stan::math::lb_constrain(tau_phi, 0, lp__);
+      } else {
+        current_statement__ = 4;
+        tau_phi = stan::math::lb_constrain(tau_phi, 0);
+      }
+      current_statement__ = 5;
+      validate_non_negative_index("theta_std", "N", N);
+      Eigen::Matrix<local_scalar_t__, -1, 1> theta_std;
+      theta_std = Eigen::Matrix<local_scalar_t__, -1, 1>(N);
+      stan::math::fill(theta_std, DUMMY_VAR__);
+      
+      current_statement__ = 5;
+      theta_std = in__.vector(N);
+      current_statement__ = 6;
+      validate_non_negative_index("phi_std_raw", "N", N);
+      Eigen::Matrix<local_scalar_t__, -1, 1> phi_std_raw;
+      phi_std_raw = Eigen::Matrix<local_scalar_t__, -1, 1>(N);
+      stan::math::fill(phi_std_raw, DUMMY_VAR__);
+      
+      current_statement__ = 6;
+      phi_std_raw = in__.vector(N);
+      local_scalar_t__ sigma_phi;
+      sigma_phi = DUMMY_VAR__;
+      
+      lcm_sym24__ = inv_sqrt(tau_phi);
+      sigma_phi = lcm_sym24__;
+      current_statement__ = 8;
+      validate_non_negative_index("phi", "N", N);
+      Eigen::Matrix<local_scalar_t__, -1, 1> phi;
+      phi = Eigen::Matrix<local_scalar_t__, -1, 1>(N);
+      stan::math::fill(phi, DUMMY_VAR__);
+      
+      current_statement__ = 9;
+      assign(phi, cons_list(index_min_max(1, N), nil_index_list()),
+        phi_std_raw, "assigning variable phi");
+      current_statement__ = 10;
+      assign(phi, nil_index_list(),
+        multiply(stan::model::deep_copy(phi), lcm_sym24__),
+        "assigning variable phi");
+      current_statement__ = 7;
+      current_statement__ = 7;
+      check_greater_or_equal(function__, "sigma_phi", lcm_sym24__, 0);
+      {
+        current_statement__ = 11;
+        lp_accum__.add(
+          dot_self(
+            rvalue(phi, cons_list(index_multi(node1), nil_index_list()),
+              "phi")));
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "expr_prop_fail8_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym21__;
+      double lcm_sym20__;
+      double lcm_sym19__;
+      double lcm_sym18__;
+      double lcm_sym17__;
+      double lcm_sym16__;
+      double lcm_sym15__;
+      Eigen::Matrix<double, -1, 1> lcm_sym14__;
+      int lcm_sym13__;
+      int lcm_sym12__;
+      int lcm_sym11__;
+      double beta0;
+      beta0 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      beta0 = in__.scalar();
+      double beta1;
+      beta1 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      beta1 = in__.scalar();
+      double tau_theta;
+      tau_theta = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      tau_theta = in__.scalar();
+      current_statement__ = 3;
+      tau_theta = stan::math::lb_constrain(tau_theta, 0);
+      double tau_phi;
+      tau_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      tau_phi = in__.scalar();
+      current_statement__ = 4;
+      tau_phi = stan::math::lb_constrain(tau_phi, 0);
+      current_statement__ = 5;
+      validate_non_negative_index("theta_std", "N", N);
+      Eigen::Matrix<double, -1, 1> theta_std;
+      theta_std = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(theta_std, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 5;
+      theta_std = in__.vector(N);
+      current_statement__ = 6;
+      validate_non_negative_index("phi_std_raw", "N", N);
+      Eigen::Matrix<double, -1, 1> phi_std_raw;
+      phi_std_raw = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(phi_std_raw, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 6;
+      phi_std_raw = in__.vector(N);
+      double sigma_phi;
+      sigma_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 8;
+      validate_non_negative_index("phi", "N", N);
+      Eigen::Matrix<double, -1, 1> phi;
+      phi = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(phi, std::numeric_limits<double>::quiet_NaN());
+      
+      vars__.push_back(beta0);
+      vars__.push_back(beta1);
+      vars__.push_back(tau_theta);
+      vars__.push_back(tau_phi);
+      lcm_sym11__ = logical_gte(N, 1);
+      if (lcm_sym11__) {
+        vars__.push_back(
+          rvalue(theta_std, cons_list(index_uni(1), nil_index_list()),
+            "theta_std"));
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          vars__.push_back(theta_std[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym11__) {
+        vars__.push_back(
+          rvalue(phi_std_raw, cons_list(index_uni(1), nil_index_list()),
+            "phi_std_raw"));
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          vars__.push_back(phi_std_raw[(sym1__ - 1)]);}
+      } 
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      lcm_sym15__ = inv_sqrt(tau_phi);
+      sigma_phi = lcm_sym15__;
+      current_statement__ = 9;
+      assign(phi, cons_list(index_min_max(1, N), nil_index_list()),
+        phi_std_raw, "assigning variable phi");
+      current_statement__ = 10;
+      assign(phi, nil_index_list(),
+        multiply(stan::model::deep_copy(phi), lcm_sym15__),
+        "assigning variable phi");
+      vars__.push_back(lcm_sym15__);
+      if (lcm_sym11__) {
+        vars__.push_back(
+          rvalue(phi, cons_list(index_uni(1), nil_index_list()), "phi"));
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          vars__.push_back(phi[(sym1__ - 1)]);}
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym10__;
+      double lcm_sym9__;
+      double lcm_sym8__;
+      double lcm_sym7__;
+      double lcm_sym6__;
+      double lcm_sym5__;
+      double lcm_sym4__;
+      double lcm_sym3__;
+      int lcm_sym2__;
+      int lcm_sym1__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double beta0;
+      beta0 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      beta0 = context__.vals_r("beta0")[(1 - 1)];
+      double beta1;
+      beta1 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      beta1 = context__.vals_r("beta1")[(1 - 1)];
+      double tau_theta;
+      tau_theta = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      tau_theta = context__.vals_r("tau_theta")[(1 - 1)];
+      current_statement__ = 3;
+      tau_theta = stan::math::lb_free(tau_theta, 0);
+      double tau_phi;
+      tau_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      tau_phi = context__.vals_r("tau_phi")[(1 - 1)];
+      current_statement__ = 4;
+      tau_phi = stan::math::lb_free(tau_phi, 0);
+      current_statement__ = 5;
+      validate_non_negative_index("theta_std", "N", N);
+      Eigen::Matrix<double, -1, 1> theta_std;
+      theta_std = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(theta_std, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> theta_std_flat__;
+        current_statement__ = 5;
+        assign(theta_std_flat__, nil_index_list(),
+          context__.vals_r("theta_std"),
+          "assigning variable theta_std_flat__");
+        current_statement__ = 5;
+        pos__ = 1;
+        lcm_sym1__ = logical_gte(N, 1);
+        if (lcm_sym1__) {
+          current_statement__ = 5;
+          assign(theta_std, cons_list(index_uni(1), nil_index_list()),
+            rvalue(theta_std_flat__,
+              cons_list(index_uni(1), nil_index_list()), "theta_std_flat__"),
+            "assigning variable theta_std");
+          current_statement__ = 5;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 5;
+            assign(theta_std, cons_list(index_uni(sym1__), nil_index_list()),
+              theta_std_flat__[(pos__ - 1)], "assigning variable theta_std");
+            current_statement__ = 5;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 6;
+      validate_non_negative_index("phi_std_raw", "N", N);
+      Eigen::Matrix<double, -1, 1> phi_std_raw;
+      phi_std_raw = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(phi_std_raw, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> phi_std_raw_flat__;
+        current_statement__ = 6;
+        assign(phi_std_raw_flat__, nil_index_list(),
+          context__.vals_r("phi_std_raw"),
+          "assigning variable phi_std_raw_flat__");
+        current_statement__ = 6;
+        pos__ = 1;
+        current_statement__ = 6;
+        if (lcm_sym1__) {
+          current_statement__ = 6;
+          assign(phi_std_raw, cons_list(index_uni(1), nil_index_list()),
+            rvalue(phi_std_raw_flat__,
+              cons_list(index_uni(1), nil_index_list()),
+              "phi_std_raw_flat__"), "assigning variable phi_std_raw");
+          current_statement__ = 6;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 6;
+            assign(phi_std_raw,
+              cons_list(index_uni(sym1__), nil_index_list()),
+              phi_std_raw_flat__[(pos__ - 1)],
+              "assigning variable phi_std_raw");
+            current_statement__ = 6;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      vars__.push_back(beta0);
+      vars__.push_back(beta1);
+      vars__.push_back(tau_theta);
+      vars__.push_back(tau_phi);
+      if (lcm_sym1__) {
+        vars__.push_back(
+          rvalue(theta_std, cons_list(index_uni(1), nil_index_list()),
+            "theta_std"));
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          vars__.push_back(theta_std[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym1__) {
+        vars__.push_back(
+          rvalue(phi_std_raw, cons_list(index_uni(1), nil_index_list()),
+            "phi_std_raw"));
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          vars__.push_back(phi_std_raw[(sym1__ - 1)]);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("beta0");
+    names__.push_back("beta1");
+    names__.push_back("tau_theta");
+    names__.push_back("tau_phi");
+    names__.push_back("theta_std");
+    names__.push_back("phi_std_raw");
+    names__.push_back("sigma_phi");
+    names__.push_back("phi");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(N);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(N);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(N);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "beta0");
+    param_names__.push_back(std::string() + "beta1");
+    param_names__.push_back(std::string() + "tau_theta");
+    param_names__.push_back(std::string() + "tau_phi");
+    for (int sym36__ = 1; sym36__ <= N; ++sym36__) {
+      {
+        param_names__.push_back(std::string() + "theta_std" + '.' + std::to_string(sym36__));
+      }}
+    for (int sym36__ = 1; sym36__ <= N; ++sym36__) {
+      {
+        param_names__.push_back(std::string() + "phi_std_raw" + '.' + std::to_string(sym36__));
+      }}
+    if (emit_transformed_parameters__) {
+      param_names__.push_back(std::string() + "sigma_phi");
+      for (int sym36__ = 1; sym36__ <= N; ++sym36__) {
+        {
+          param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym36__));
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "beta0");
+    param_names__.push_back(std::string() + "beta1");
+    param_names__.push_back(std::string() + "tau_theta");
+    param_names__.push_back(std::string() + "tau_phi");
+    for (int sym36__ = 1; sym36__ <= N; ++sym36__) {
+      {
+        param_names__.push_back(std::string() + "theta_std" + '.' + std::to_string(sym36__));
+      }}
+    for (int sym36__ = 1; sym36__ <= N; ++sym36__) {
+      {
+        param_names__.push_back(std::string() + "phi_std_raw" + '.' + std::to_string(sym36__));
+      }}
+    if (emit_transformed_parameters__) {
+      param_names__.push_back(std::string() + "sigma_phi");
+      for (int sym36__ = 1; sym36__ <= N; ++sym36__) {
+        {
+          param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym36__));
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"beta0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"tau_theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"tau_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"theta_std\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"parameters\"},{\"name\":\"phi_std_raw\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"parameters\"},{\"name\":\"sigma_phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"beta0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"tau_theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"tau_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"theta_std\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"parameters\"},{\"name\":\"phi_std_raw\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"parameters\"},{\"name\":\"sigma_phi\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef expr_prop_fail8_model_namespace::expr_prop_fail8_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp fails-test.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace fails_test_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'fails-test.stan', line 71, column 2 to column 31)",
+                                                      " (in 'fails-test.stan', line 72, column 2 to column 40)",
+                                                      " (in 'fails-test.stan', line 76, column 2 to column 51)",
+                                                      " (in 'fails-test.stan', line 77, column 2 to column 49)",
+                                                      " (in 'fails-test.stan', line 78, column 2 to column 49)",
+                                                      " (in 'fails-test.stan', line 83, column 6 to column 20)",
+                                                      " (in 'fails-test.stan', line 84, column 6 to column 18)",
+                                                      " (in 'fails-test.stan', line 82, column 32 to line 85, column 5)",
+                                                      " (in 'fails-test.stan', line 87, column 6 to column 32)",
+                                                      " (in 'fails-test.stan', line 88, column 6 to column 23)",
+                                                      " (in 'fails-test.stan', line 86, column 38 to line 89, column 5)",
+                                                      " (in 'fails-test.stan', line 86, column 4 to line 89, column 5)",
+                                                      " (in 'fails-test.stan', line 81, column 20 to line 90, column 3)",
+                                                      " (in 'fails-test.stan', line 26, column 4 to column 34)",
+                                                      " (in 'fails-test.stan', line 29, column 6 to column 32)",
+                                                      " (in 'fails-test.stan', line 32, column 8 to column 37)",
+                                                      " (in 'fails-test.stan', line 33, column 8 to column 32)",
+                                                      " (in 'fails-test.stan', line 41, column 8 to line 42, column 83)",
+                                                      " (in 'fails-test.stan', line 30, column 37 to line 43, column 7)",
+                                                      " (in 'fails-test.stan', line 28, column 22 to line 44, column 5)",
+                                                      " (in 'fails-test.stan', line 25, column 47 to line 46, column 3)",
+                                                      " (in 'fails-test.stan', line 105, column 8 to column 37)",
+                                                      " (in 'fails-test.stan', line 106, column 8 to column 41)",
+                                                      " (in 'fails-test.stan', line 104, column 40 to line 107, column 7)",
+                                                      " (in 'fails-test.stan', line 108, column 6 to column 37)",
+                                                      " (in 'fails-test.stan', line 103, column 22 to line 109, column 5)",
+                                                      " (in 'fails-test.stan', line 102, column 20 to line 110, column 3)",
+                                                      " (in 'fails-test.stan', line 102, column 2 to line 110, column 3)",
+                                                      " (in 'fails-test.stan', line 50, column 2 to column 20)",
+                                                      " (in 'fails-test.stan', line 51, column 2 to column 27)",
+                                                      " (in 'fails-test.stan', line 52, column 2 to column 44)",
+                                                      " (in 'fails-test.stan', line 53, column 2 to column 23)",
+                                                      " (in 'fails-test.stan', line 54, column 2 to column 54)",
+                                                      " (in 'fails-test.stan', line 58, column 2 to column 38)",
+                                                      " (in 'fails-test.stan', line 60, column 2 to column 45)",
+                                                      " (in 'fails-test.stan', line 61, column 2 to column 44)",
+                                                      " (in 'fails-test.stan', line 8, column 8 to column 17)",
+                                                      " (in 'fails-test.stan', line 7, column 6 to line 8, column 17)",
+                                                      " (in 'fails-test.stan', line 5, column 31 to line 10, column 3)",
+                                                      " (in 'fails-test.stan', line 65, column 4 to column 35)",
+                                                      " (in 'fails-test.stan', line 64, column 2 to line 65, column 35)",
+                                                      " (in 'fails-test.stan', line 15, column 6 to column 32)",
+                                                      " (in 'fails-test.stan', line 19, column 8 to column 17)",
+                                                      " (in 'fails-test.stan', line 18, column 6 to line 19, column 17)",
+                                                      " (in 'fails-test.stan', line 13, column 37 to line 20, column 5)",
+                                                      " (in 'fails-test.stan', line 12, column 30 to line 22, column 3)",
+                                                      " (in 'fails-test.stan', line 67, column 4 to column 33)",
+                                                      " (in 'fails-test.stan', line 66, column 2 to line 67, column 33)",
+                                                      " (in 'fails-test.stan', line 9, column 4 to column 13)",
+                                                      " (in 'fails-test.stan', line 21, column 4 to column 13)",
+                                                      " (in 'fails-test.stan', line 30, column 6 to line 43, column 7)",
+                                                      " (in 'fails-test.stan', line 28, column 4 to line 44, column 5)",
+                                                      " (in 'fails-test.stan', line 45, column 4 to column 15)"};
+
+
+int
+first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym29__;
+    int lcm_sym28__;
+    int lcm_sym27__;
+    int lcm_sym26__;
+    {
+      lcm_sym27__ = size(y_i);
+      if (logical_gte(lcm_sym27__, 1)) {
+        current_statement__ = 38;
+        if (rvalue(y_i, cons_list(index_uni(1), nil_index_list()), "y_i")) {
+          current_statement__ = 37;
+          return 1;
+        } 
+        for (int k = 2; k <= lcm_sym27__; ++k) {
+          current_statement__ = 38;
+          if (rvalue(y_i, cons_list(index_uni(k), nil_index_list()), "y_i")) {
+            current_statement__ = 37;
+            return k;
+          } }
+      } 
+      current_statement__ = 49;
+      return 0;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct first_capture_functor__ {
+int
+operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+{
+return first_capture(y_i, pstream__);
+}
+};
+
+int
+last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym35__;
+    int lcm_sym34__;
+    int lcm_sym33__;
+    int lcm_sym32__;
+    int lcm_sym31__;
+    int lcm_sym30__;
+    {
+      lcm_sym33__ = (size(y_i) - 1);
+      if (logical_gte(lcm_sym33__, 0)) {
+        int k;
+        k = std::numeric_limits<int>::min();
+        
+        lcm_sym32__ = (size(y_i) - 0);
+        current_statement__ = 44;
+        if (y_i[(lcm_sym32__ - 1)]) {
+          current_statement__ = 43;
+          return lcm_sym32__;
+        } 
+        for (int k_rev = 1; k_rev <= lcm_sym33__; ++k_rev) {
+          int k;
+          k = std::numeric_limits<int>::min();
+          
+          lcm_sym31__ = (size(y_i) - k_rev);
+          current_statement__ = 44;
+          if (y_i[(lcm_sym31__ - 1)]) {
+            current_statement__ = 43;
+            return lcm_sym31__;
+          } }
+      } 
+      current_statement__ = 50;
+      return 0;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct last_capture_functor__ {
+int
+operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+{
+return last_capture(y_i, pstream__);
+}
+};
+
+template <typename T2__, typename T3__>
+Eigen::Matrix<stan::promote_args_t<T2__,
+T3__>, -1, -1>
+prob_uncaptured(const int& nind, const int& n_occasions,
+                const Eigen::Matrix<T2__, -1, -1>& p,
+                const Eigen::Matrix<T3__, -1, -1>& phi,
+                std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<T2__, T3__>;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    double lcm_sym45__;
+    double lcm_sym44__;
+    double lcm_sym43__;
+    double lcm_sym42__;
+    int lcm_sym41__;
+    int lcm_sym40__;
+    int lcm_sym39__;
+    int lcm_sym38__;
+    int lcm_sym37__;
+    int lcm_sym36__;
+    {
+      current_statement__ = 14;
+      validate_non_negative_index("chi", "nind", nind);
+      current_statement__ = 14;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      current_statement__ = 52;
+      if (logical_gte(nind, 1)) {
+        current_statement__ = 15;
+        assign(chi,
+          cons_list(index_uni(1),
+            cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+          "assigning variable chi");
+        lcm_sym39__ = (n_occasions - 1);
+        lcm_sym37__ = logical_gte(lcm_sym39__, 1);
+        if (lcm_sym37__) {
+          int t_curr;
+          t_curr = std::numeric_limits<int>::min();
+          
+          int t_next;
+          t_next = std::numeric_limits<int>::min();
+          
+          lcm_sym41__ = (lcm_sym39__ + 1);
+          current_statement__ = 18;
+          assign(chi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym39__), nil_index_list())),
+            stan::math::fma(
+              (rvalue(phi,
+                 cons_list(index_uni(1),
+                   cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                 "phi") *
+                (1 -
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((lcm_sym41__ - 1)),
+                        nil_index_list())), "p"))),
+              rvalue(chi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(lcm_sym41__), nil_index_list())),
+                "chi"),
+              (1 -
+                rvalue(phi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                  "phi"))), "assigning variable chi");
+          for (int t = 2; t <= lcm_sym39__; ++t) {
+            int t_curr;
+            t_curr = std::numeric_limits<int>::min();
+            
+            lcm_sym38__ = (n_occasions - t);
+            int t_next;
+            t_next = std::numeric_limits<int>::min();
+            
+            lcm_sym40__ = (lcm_sym38__ + 1);
+            current_statement__ = 18;
+            assign(chi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(lcm_sym38__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(1),
+                     cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((lcm_sym40__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(chi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym40__), nil_index_list())),
+                  "chi"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                    "phi"))), "assigning variable chi");}
+        } 
+        for (int i = 2; i <= nind; ++i) {
+          current_statement__ = 15;
+          assign(chi,
+            cons_list(index_uni(i),
+              cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+            "assigning variable chi");
+          current_statement__ = 51;
+          if (lcm_sym37__) {
+            int t_curr;
+            t_curr = std::numeric_limits<int>::min();
+            
+            int t_next;
+            t_next = std::numeric_limits<int>::min();
+            
+            lcm_sym41__ = (lcm_sym39__ + 1);
+            current_statement__ = 18;
+            assign(chi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym39__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(i),
+                     cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((lcm_sym41__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(chi,
+                  cons_list(index_uni(i),
+                    cons_list(index_uni(lcm_sym41__), nil_index_list())),
+                  "chi"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                    "phi"))), "assigning variable chi");
+            for (int t = 2; t <= lcm_sym39__; ++t) {
+              int t_curr;
+              t_curr = std::numeric_limits<int>::min();
+              
+              lcm_sym38__ = (n_occasions - t);
+              int t_next;
+              t_next = std::numeric_limits<int>::min();
+              
+              lcm_sym40__ = (lcm_sym38__ + 1);
+              current_statement__ = 18;
+              assign(chi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(i),
+                       cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((lcm_sym40__ - 1)),
+                            nil_index_list())), "p"))),
+                  rvalue(chi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym40__), nil_index_list())),
+                    "chi"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                      "phi"))), "assigning variable chi");}
+          } }
+      } 
+      current_statement__ = 53;
+      return chi;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct prob_uncaptured_functor__ {
+template <typename T2__, typename T3__>
+Eigen::Matrix<stan::promote_args_t<T2__,
+T3__>, -1, -1>
+operator()(const int& nind, const int& n_occasions,
+           const Eigen::Matrix<T2__, -1, -1>& p,
+           const Eigen::Matrix<T3__, -1, -1>& phi, std::ostream* pstream__)  const 
+{
+return prob_uncaptured(nind, n_occasions, p, phi, pstream__);
+}
+};
+
+class fails_test_model : 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 lcm_sym158__;
+  int lcm_sym157__;
+  int lcm_sym156__;
+  int lcm_sym155__;
+  int lcm_sym154__;
+  int lcm_sym153__;
+  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 lcm_sym142__;
+  int lcm_sym141__;
+  int pos__;
+  int nind;
+  int n_occasions;
+  std::vector<std::vector<int>> y;
+  int max_age;
+  std::vector<std::vector<int>> x;
+  int n_occ_minus_1;
+  std::vector<int> first;
+  std::vector<int> last;
+ 
+ public:
+  ~fails_test_model() { }
+  
+  std::string model_name() const { return "fails_test_model"; }
+  
+  fails_test_model(stan::io::var_context& context__,
+                   unsigned int random_seed__ = 0,
+                   std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "fails_test_model_namespace::fails_test_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","nind","int",
+          context__.to_vec());
+      nind = std::numeric_limits<int>::min();
+      
+      current_statement__ = 29;
+      nind = context__.vals_i("nind")[(1 - 1)];
+      context__.validate_dims("data initialization","n_occasions","int",
+          context__.to_vec());
+      n_occasions = std::numeric_limits<int>::min();
+      
+      current_statement__ = 30;
+      n_occasions = context__.vals_i("n_occasions")[(1 - 1)];
+      current_statement__ = 31;
+      validate_non_negative_index("y", "nind", nind);
+      current_statement__ = 31;
+      validate_non_negative_index("y", "n_occasions", n_occasions);
+      context__.validate_dims("data initialization","y","int",
+          context__.to_vec(nind, n_occasions));
+      y = std::vector<std::vector<int>>(nind, std::vector<int>(n_occasions, std::numeric_limits<int>::min()));
+      
+      {
+        std::vector<int> y_flat__;
+        current_statement__ = 31;
+        assign(y_flat__, nil_index_list(), context__.vals_i("y"),
+          "assigning variable y_flat__");
+        current_statement__ = 31;
+        pos__ = 1;
+        lcm_sym141__ = logical_gte(n_occasions, 1);
+        if (lcm_sym141__) {
+          {
+            lcm_sym142__ = logical_gte(nind, 1);
+            if (lcm_sym142__) {
+              current_statement__ = 31;
+              assign(y,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(1), nil_index_list())),
+                rvalue(y_flat__, cons_list(index_uni(1), nil_index_list()),
+                  "y_flat__"), "assigning variable y");
+              current_statement__ = 31;
+              pos__ = 2;
+              for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+                current_statement__ = 31;
+                assign(y,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(1), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 31;
+                pos__ = (pos__ + 1);}
+            } 
+            for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+              current_statement__ = 31;
+              if (lcm_sym142__) {
+                current_statement__ = 31;
+                assign(y,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 31;
+                pos__ = (pos__ + 1);
+                for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+                  current_statement__ = 31;
+                  assign(y,
+                    cons_list(index_uni(sym2__),
+                      cons_list(index_uni(sym1__), nil_index_list())),
+                    y_flat__[(pos__ - 1)], "assigning variable y");
+                  current_statement__ = 31;
+                  pos__ = (pos__ + 1);}
+              } }
+          }
+        } else {
+          lcm_sym142__ = logical_gte(nind, 1);
+        }
+      }
+      context__.validate_dims("data initialization","max_age","int",
+          context__.to_vec());
+      max_age = std::numeric_limits<int>::min();
+      
+      current_statement__ = 32;
+      max_age = context__.vals_i("max_age")[(1 - 1)];
+      current_statement__ = 33;
+      validate_non_negative_index("x", "nind", nind);
+      lcm_sym144__ = (n_occasions - 1);
+      validate_non_negative_index("x", "(n_occasions - 1)", lcm_sym144__);
+      context__.validate_dims("data initialization","x","int",
+          context__.to_vec(nind, lcm_sym144__));
+      x = std::vector<std::vector<int>>(nind, std::vector<int>(lcm_sym144__, std::numeric_limits<int>::min()));
+      
+      {
+        std::vector<int> x_flat__;
+        current_statement__ = 33;
+        assign(x_flat__, nil_index_list(), context__.vals_i("x"),
+          "assigning variable x_flat__");
+        current_statement__ = 33;
+        pos__ = 1;
+        lcm_sym143__ = logical_gte(lcm_sym144__, 1);
+        if (lcm_sym143__) {
+          current_statement__ = 33;
+          if (lcm_sym142__) {
+            current_statement__ = 33;
+            assign(x,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())),
+              rvalue(x_flat__, cons_list(index_uni(1), nil_index_list()),
+                "x_flat__"), "assigning variable x");
+            current_statement__ = 33;
+            pos__ = 2;
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              current_statement__ = 33;
+              assign(x,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())),
+                x_flat__[(pos__ - 1)], "assigning variable x");
+              current_statement__ = 33;
+              pos__ = (pos__ + 1);}
+          } 
+          for (int sym1__ = 2; sym1__ <= lcm_sym144__; ++sym1__) {
+            current_statement__ = 33;
+            if (lcm_sym142__) {
+              current_statement__ = 33;
+              assign(x,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                x_flat__[(pos__ - 1)], "assigning variable x");
+              current_statement__ = 33;
+              pos__ = (pos__ + 1);
+              for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+                current_statement__ = 33;
+                assign(x,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  x_flat__[(pos__ - 1)], "assigning variable x");
+                current_statement__ = 33;
+                pos__ = (pos__ + 1);}
+            } }
+        } 
+      }
+      n_occ_minus_1 = std::numeric_limits<int>::min();
+      
+      current_statement__ = 34;
+      n_occ_minus_1 = lcm_sym144__;
+      current_statement__ = 35;
+      validate_non_negative_index("first", "nind", nind);
+      first = std::vector<int>(nind, std::numeric_limits<int>::min());
+      
+      current_statement__ = 36;
+      validate_non_negative_index("last", "nind", nind);
+      last = std::vector<int>(nind, std::numeric_limits<int>::min());
+      
+      current_statement__ = 41;
+      if (lcm_sym142__) {
+        int inline_sym17__;
+        int inline_sym19__;
+        inline_sym19__ = std::numeric_limits<int>::min();
+        
+        inline_sym19__ = 0;
+        for (int inline_sym20__ = 1; inline_sym20__ <= 1; ++inline_sym20__) {
+          lcm_sym151__ = size(
+                           rvalue(y,
+                             cons_list(index_uni(1), nil_index_list()), "y"));
+          for (int inline_sym18__ = 1; inline_sym18__ <= lcm_sym151__;
+               ++inline_sym18__) {
+            current_statement__ = 38;
+            if (rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")[
+                (inline_sym18__ - 1)]) {
+              inline_sym19__ = 1;
+              inline_sym17__ = inline_sym18__;
+              break;
+            } }
+          if (inline_sym19__) {
+            break;
+          } 
+          inline_sym19__ = 1;
+          inline_sym17__ = 0;
+          break;}
+        assign(first, cons_list(index_uni(1), nil_index_list()),
+          inline_sym17__, "assigning variable first");
+        for (int i = 2; i <= nind; ++i) {
+          int inline_sym17__;
+          int inline_sym19__;
+          inline_sym19__ = std::numeric_limits<int>::min();
+          
+          inline_sym19__ = 0;
+          for (int inline_sym20__ = 1; inline_sym20__ <= 1; ++inline_sym20__) {
+            lcm_sym150__ = size(
+                             rvalue(y,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "y"));
+            for (int inline_sym18__ = 1; inline_sym18__ <= lcm_sym150__;
+                 ++inline_sym18__) {
+              current_statement__ = 38;
+              if (rvalue(y, cons_list(index_uni(i), nil_index_list()), "y")[
+                  (inline_sym18__ - 1)]) {
+                inline_sym19__ = 1;
+                inline_sym17__ = inline_sym18__;
+                break;
+              } }
+            if (inline_sym19__) {
+              break;
+            } 
+            inline_sym19__ = 1;
+            inline_sym17__ = 0;
+            break;}
+          assign(first, cons_list(index_uni(i), nil_index_list()),
+            inline_sym17__, "assigning variable first");}
+      } 
+      current_statement__ = 48;
+      if (lcm_sym142__) {
+        int inline_sym21__;
+        int inline_sym24__;
+        inline_sym24__ = std::numeric_limits<int>::min();
+        
+        inline_sym24__ = 0;
+        for (int inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) {
+          lcm_sym151__ = size(
+                           rvalue(y,
+                             cons_list(index_uni(1), nil_index_list()), "y"));
+          lcm_sym148__ = (lcm_sym151__ - 1);
+          for (int inline_sym23__ = 0; inline_sym23__ <= lcm_sym148__;
+               ++inline_sym23__) {
+            int inline_sym22__;
+            inline_sym22__ = std::numeric_limits<int>::min();
+            
+            lcm_sym147__ = (lcm_sym151__ - inline_sym23__);
+            inline_sym22__ = lcm_sym147__;
+            current_statement__ = 44;
+            if (rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")[
+                (lcm_sym147__ - 1)]) {
+              inline_sym24__ = 1;
+              inline_sym21__ = lcm_sym147__;
+              break;
+            } }
+          if (inline_sym24__) {
+            break;
+          } 
+          inline_sym24__ = 1;
+          inline_sym21__ = 0;
+          break;}
+        assign(last, cons_list(index_uni(1), nil_index_list()),
+          inline_sym21__, "assigning variable last");
+        for (int i = 2; i <= nind; ++i) {
+          int inline_sym21__;
+          int inline_sym24__;
+          inline_sym24__ = std::numeric_limits<int>::min();
+          
+          inline_sym24__ = 0;
+          for (int inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) {
+            lcm_sym150__ = size(
+                             rvalue(y,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "y"));
+            lcm_sym146__ = (lcm_sym150__ - 1);
+            for (int inline_sym23__ = 0; inline_sym23__ <= lcm_sym146__;
+                 ++inline_sym23__) {
+              int inline_sym22__;
+              inline_sym22__ = std::numeric_limits<int>::min();
+              
+              lcm_sym145__ = (lcm_sym150__ - inline_sym23__);
+              inline_sym22__ = lcm_sym145__;
+              current_statement__ = 44;
+              if (rvalue(y, cons_list(index_uni(i), nil_index_list()), "y")[
+                  (lcm_sym145__ - 1)]) {
+                inline_sym24__ = 1;
+                inline_sym21__ = lcm_sym145__;
+                break;
+              } }
+            if (inline_sym24__) {
+              break;
+            } 
+            inline_sym24__ = 1;
+            inline_sym21__ = 0;
+            break;}
+          assign(last, cons_list(index_uni(i), nil_index_list()),
+            inline_sym21__, "assigning variable last");}
+      } 
+      current_statement__ = 29;
+      current_statement__ = 29;
+      check_greater_or_equal(function__, "nind", nind, 0);
+      current_statement__ = 30;
+      current_statement__ = 30;
+      check_greater_or_equal(function__, "n_occasions", n_occasions, 2);
+      current_statement__ = 31;
+      if (lcm_sym142__) {
+        current_statement__ = 31;
+        if (lcm_sym141__) {
+          current_statement__ = 31;
+          current_statement__ = 31;
+          check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                 rvalue(y,
+                                   cons_list(index_uni(1),
+                                     cons_list(index_uni(1),
+                                       nil_index_list())), "y"), 0);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 31;
+            current_statement__ = 31;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(1),
+                                       cons_list(index_uni(sym2__),
+                                         nil_index_list())), "y"), 0);}
+        } 
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 31;
+          if (lcm_sym141__) {
+            current_statement__ = 31;
+            current_statement__ = 31;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(sym1__),
+                                       cons_list(index_uni(1),
+                                         nil_index_list())), "y"), 0);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 31;
+              current_statement__ = 31;
+              check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                     y[(sym1__ - 1)][(sym2__ - 1)], 0);}
+          } }
+      } 
+      current_statement__ = 31;
+      if (lcm_sym142__) {
+        current_statement__ = 31;
+        if (lcm_sym141__) {
+          current_statement__ = 31;
+          current_statement__ = 31;
+          check_less_or_equal(function__, "y[sym1__, sym2__]",
+                              rvalue(y,
+                                cons_list(index_uni(1),
+                                  cons_list(index_uni(1), nil_index_list())),
+                                "y"), 1);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 31;
+            current_statement__ = 31;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(1),
+                                    cons_list(index_uni(sym2__),
+                                      nil_index_list())), "y"), 1);}
+        } 
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 31;
+          if (lcm_sym141__) {
+            current_statement__ = 31;
+            current_statement__ = 31;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(sym1__),
+                                    cons_list(index_uni(1), nil_index_list())),
+                                  "y"), 1);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 31;
+              current_statement__ = 31;
+              check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                  y[(sym1__ - 1)][(sym2__ - 1)], 1);}
+          } }
+      } 
+      current_statement__ = 32;
+      current_statement__ = 32;
+      check_greater_or_equal(function__, "max_age", max_age, 1);
+      current_statement__ = 33;
+      if (lcm_sym142__) {
+        current_statement__ = 33;
+        if (lcm_sym143__) {
+          current_statement__ = 33;
+          current_statement__ = 33;
+          check_greater_or_equal(function__, "x[sym1__, sym2__]",
+                                 rvalue(x,
+                                   cons_list(index_uni(1),
+                                     cons_list(index_uni(1),
+                                       nil_index_list())), "x"), 0);
+          for (int sym2__ = 2; sym2__ <= lcm_sym144__; ++sym2__) {
+            current_statement__ = 33;
+            current_statement__ = 33;
+            check_greater_or_equal(function__, "x[sym1__, sym2__]",
+                                   rvalue(x,
+                                     cons_list(index_uni(1),
+                                       cons_list(index_uni(sym2__),
+                                         nil_index_list())), "x"), 0);}
+        } 
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 33;
+          if (lcm_sym143__) {
+            current_statement__ = 33;
+            current_statement__ = 33;
+            check_greater_or_equal(function__, "x[sym1__, sym2__]",
+                                   rvalue(x,
+                                     cons_list(index_uni(sym1__),
+                                       cons_list(index_uni(1),
+                                         nil_index_list())), "x"), 0);
+            for (int sym2__ = 2; sym2__ <= lcm_sym144__; ++sym2__) {
+              current_statement__ = 33;
+              current_statement__ = 33;
+              check_greater_or_equal(function__, "x[sym1__, sym2__]",
+                                     x[(sym1__ - 1)][(sym2__ - 1)], 0);}
+          } }
+      } 
+      current_statement__ = 33;
+      if (lcm_sym142__) {
+        current_statement__ = 33;
+        if (lcm_sym143__) {
+          current_statement__ = 33;
+          current_statement__ = 33;
+          check_less_or_equal(function__, "x[sym1__, sym2__]",
+                              rvalue(x,
+                                cons_list(index_uni(1),
+                                  cons_list(index_uni(1), nil_index_list())),
+                                "x"), max_age);
+          for (int sym2__ = 2; sym2__ <= lcm_sym144__; ++sym2__) {
+            current_statement__ = 33;
+            current_statement__ = 33;
+            check_less_or_equal(function__, "x[sym1__, sym2__]",
+                                rvalue(x,
+                                  cons_list(index_uni(1),
+                                    cons_list(index_uni(sym2__),
+                                      nil_index_list())), "x"), max_age);}
+        } 
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 33;
+          if (lcm_sym143__) {
+            current_statement__ = 33;
+            current_statement__ = 33;
+            check_less_or_equal(function__, "x[sym1__, sym2__]",
+                                rvalue(x,
+                                  cons_list(index_uni(sym1__),
+                                    cons_list(index_uni(1), nil_index_list())),
+                                  "x"), max_age);
+            for (int sym2__ = 2; sym2__ <= lcm_sym144__; ++sym2__) {
+              current_statement__ = 33;
+              current_statement__ = 33;
+              check_less_or_equal(function__, "x[sym1__, sym2__]",
+                                  x[(sym1__ - 1)][(sym2__ - 1)], max_age);}
+          } }
+      } 
+      current_statement__ = 35;
+      if (lcm_sym142__) {
+        current_statement__ = 35;
+        current_statement__ = 35;
+        check_greater_or_equal(function__, "first[sym1__]",
+                               rvalue(first,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "first"), 0);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 35;
+          current_statement__ = 35;
+          check_greater_or_equal(function__, "first[sym1__]",
+                                 first[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 35;
+      if (lcm_sym142__) {
+        current_statement__ = 35;
+        current_statement__ = 35;
+        check_less_or_equal(function__, "first[sym1__]",
+                            rvalue(first,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "first"), n_occasions);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 35;
+          current_statement__ = 35;
+          check_less_or_equal(function__, "first[sym1__]",
+                              first[(sym1__ - 1)], n_occasions);}
+      } 
+      current_statement__ = 36;
+      if (lcm_sym142__) {
+        current_statement__ = 36;
+        current_statement__ = 36;
+        check_greater_or_equal(function__, "last[sym1__]",
+                               rvalue(last,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "last"), 0);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 36;
+          current_statement__ = 36;
+          check_greater_or_equal(function__, "last[sym1__]",
+                                 last[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 36;
+      if (lcm_sym142__) {
+        current_statement__ = 36;
+        current_statement__ = 36;
+        check_less_or_equal(function__, "last[sym1__]",
+                            rvalue(last,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "last"), n_occasions);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 36;
+          current_statement__ = 36;
+          check_less_or_equal(function__, "last[sym1__]", last[(sym1__ - 1)],
+                              n_occasions);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      current_statement__ = 2;
+      validate_non_negative_index("beta", "max_age", max_age);
+      num_params_r__ += max_age;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "fails_test_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      int lcm_sym140__;
+      int lcm_sym139__;
+      int lcm_sym138__;
+      int lcm_sym137__;
+      double lcm_sym136__;
+      double lcm_sym135__;
+      double lcm_sym134__;
+      double lcm_sym133__;
+      double lcm_sym132__;
+      double lcm_sym130__;
+      double lcm_sym128__;
+      double lcm_sym127__;
+      double lcm_sym126__;
+      double lcm_sym125__;
+      double lcm_sym124__;
+      double lcm_sym123__;
+      double lcm_sym122__;
+      double lcm_sym121__;
+      double lcm_sym120__;
+      double lcm_sym119__;
+      double lcm_sym118__;
+      double lcm_sym117__;
+      int lcm_sym116__;
+      int lcm_sym115__;
+      int lcm_sym114__;
+      int lcm_sym113__;
+      int lcm_sym112__;
+      int lcm_sym111__;
+      int lcm_sym110__;
+      int lcm_sym109__;
+      int lcm_sym108__;
+      int lcm_sym107__;
+      int lcm_sym106__;
+      int lcm_sym105__;
+      int lcm_sym104__;
+      int lcm_sym103__;
+      int lcm_sym102__;
+      int lcm_sym101__;
+      int lcm_sym100__;
+      int lcm_sym99__;
+      int lcm_sym98__;
+      int lcm_sym97__;
+      int lcm_sym96__;
+      local_scalar_t__ mean_p;
+      mean_p = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      mean_p = in__.scalar();
+      current_statement__ = 1;
+      if (jacobian__) {
+        current_statement__ = 1;
+        mean_p = stan::math::lub_constrain(mean_p, 0, 1, lp__);
+      } else {
+        current_statement__ = 1;
+        mean_p = stan::math::lub_constrain(mean_p, 0, 1);
+      }
+      current_statement__ = 2;
+      validate_non_negative_index("beta", "max_age", max_age);
+      Eigen::Matrix<local_scalar_t__, -1, 1> beta;
+      beta = Eigen::Matrix<local_scalar_t__, -1, 1>(max_age);
+      stan::math::fill(beta, DUMMY_VAR__);
+      
+      current_statement__ = 2;
+      beta = in__.vector(max_age);
+      current_statement__ = 2;
+      if (logical_gte(max_age, 1)) {
+        current_statement__ = 2;
+        if (jacobian__) {
+          current_statement__ = 2;
+          assign(beta, cons_list(index_uni(1), nil_index_list()),
+            stan::math::lub_constrain(
+              rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+              0, 1, lp__), "assigning variable beta");
+        } else {
+          current_statement__ = 2;
+          assign(beta, cons_list(index_uni(1), nil_index_list()),
+            stan::math::lub_constrain(
+              rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+              0, 1), "assigning variable beta");
+        }
+        for (int sym1__ = 2; sym1__ <= max_age; ++sym1__) {
+          current_statement__ = 2;
+          if (jacobian__) {
+            current_statement__ = 2;
+            assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+              stan::math::lub_constrain(beta[(sym1__ - 1)], 0, 1, lp__),
+              "assigning variable beta");
+          } else {
+            current_statement__ = 2;
+            assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+              stan::math::lub_constrain(beta[(sym1__ - 1)], 0, 1),
+              "assigning variable beta");
+          }}
+      } 
+      current_statement__ = 3;
+      validate_non_negative_index("phi", "nind", nind);
+      lcm_sym108__ = (n_occasions - 1);
+      validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym108__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> phi;
+      phi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, lcm_sym108__);
+      stan::math::fill(phi, DUMMY_VAR__);
+      
+      current_statement__ = 4;
+      validate_non_negative_index("p", "nind", nind);
+      current_statement__ = 4;
+      validate_non_negative_index("p", "n_occ_minus_1", lcm_sym108__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> p;
+      p = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, lcm_sym108__);
+      stan::math::fill(p, DUMMY_VAR__);
+      
+      current_statement__ = 5;
+      validate_non_negative_index("chi", "nind", nind);
+      current_statement__ = 5;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      lcm_sym97__ = logical_gte(nind, 1);
+      if (lcm_sym97__) {
+        lcm_sym138__ = rvalue(first,
+                         cons_list(index_uni(1), nil_index_list()), "first");
+        lcm_sym110__ = (lcm_sym138__ - 1);
+        if (logical_gte(lcm_sym110__, 1)) {
+          current_statement__ = 6;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable phi");
+          current_statement__ = 7;
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable p");
+          for (int t = 2; t <= lcm_sym110__; ++t) {
+            current_statement__ = 6;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 7;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable p");}
+        } 
+        current_statement__ = 12;
+        if (logical_gte(lcm_sym108__, lcm_sym138__)) {
+          current_statement__ = 9;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym138__), nil_index_list())),
+            rvalue(beta,
+              cons_list(
+                index_uni(rvalue(x,
+                            cons_list(index_uni(1),
+                              cons_list(index_uni(lcm_sym138__),
+                                nil_index_list())), "x")), nil_index_list()),
+              "beta"), "assigning variable phi");
+          lcm_sym116__ = (lcm_sym138__ + 1);
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym138__), nil_index_list())), mean_p,
+            "assigning variable p");
+          for (int t = lcm_sym116__; t <= lcm_sym108__; ++t) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())),
+              rvalue(beta,
+                cons_list(
+                  index_uni(rvalue(x,
+                              cons_list(index_uni(1),
+                                cons_list(index_uni(t), nil_index_list())),
+                              "x")), nil_index_list()), "beta"),
+              "assigning variable phi");
+            current_statement__ = 10;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), mean_p,
+              "assigning variable p");}
+        } 
+        for (int i = 2; i <= nind; ++i) {
+          lcm_sym137__ = rvalue(first,
+                           cons_list(index_uni(i), nil_index_list()),
+                           "first");
+          lcm_sym109__ = (lcm_sym137__ - 1);
+          if (logical_gte(lcm_sym109__, 1)) {
+            current_statement__ = 6;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 7;
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable p");
+            for (int t = 2; t <= lcm_sym109__; ++t) {
+              current_statement__ = 6;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable phi");
+              current_statement__ = 7;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable p");}
+          } 
+          current_statement__ = 12;
+          if (logical_gte(lcm_sym108__, lcm_sym137__)) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym137__), nil_index_list())),
+              rvalue(beta,
+                cons_list(
+                  index_uni(rvalue(x,
+                              cons_list(index_uni(i),
+                                cons_list(index_uni(lcm_sym137__),
+                                  nil_index_list())), "x")),
+                  nil_index_list()), "beta"), "assigning variable phi");
+            lcm_sym115__ = (lcm_sym137__ + 1);
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym137__), nil_index_list())),
+              mean_p, "assigning variable p");
+            for (int t = lcm_sym115__; t <= lcm_sym108__; ++t) {
+              current_statement__ = 9;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())),
+                rvalue(beta,
+                  cons_list(
+                    index_uni(rvalue(x,
+                                cons_list(index_uni(i),
+                                  cons_list(index_uni(t), nil_index_list())),
+                                "x")), nil_index_list()), "beta"),
+                "assigning variable phi");
+              current_statement__ = 10;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), mean_p,
+                "assigning variable p");}
+          } }
+      } 
+      Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym9__;
+      int inline_sym15__;
+      inline_sym15__ = std::numeric_limits<int>::min();
+      
+      inline_sym15__ = 0;
+      for (int inline_sym16__ = 1; inline_sym16__ <= 1; ++inline_sym16__) {
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "nind", nind);
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "n_occasions", n_occasions);
+        Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym10__;
+        inline_sym10__ = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+        stan::math::fill(inline_sym10__, DUMMY_VAR__);
+        
+        for (int inline_sym14__ = 1; inline_sym14__ <= nind; ++inline_sym14__) {
+          current_statement__ = 15;
+          assign(inline_sym10__,
+            cons_list(index_uni(inline_sym14__),
+              cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+            "assigning variable inline_sym10__");
+          if (logical_gte(lcm_sym108__, 1)) {
+            int inline_sym11__;
+            inline_sym11__ = std::numeric_limits<int>::min();
+            
+            int inline_sym12__;
+            inline_sym12__ = std::numeric_limits<int>::min();
+            
+            lcm_sym112__ = (lcm_sym108__ + 1);
+            current_statement__ = 18;
+            assign(inline_sym10__,
+              cons_list(index_uni(inline_sym14__),
+                cons_list(index_uni(lcm_sym108__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(inline_sym14__),
+                     cons_list(index_uni(lcm_sym108__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(inline_sym14__),
+                        cons_list(index_uni((lcm_sym112__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(inline_sym10__,
+                  cons_list(index_uni(inline_sym14__),
+                    cons_list(index_uni(lcm_sym112__), nil_index_list())),
+                  "inline_sym10__"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(inline_sym14__),
+                      cons_list(index_uni(lcm_sym108__), nil_index_list())),
+                    "phi"))), "assigning variable inline_sym10__");
+            for (int inline_sym13__ = 2; inline_sym13__ <= lcm_sym108__;
+                 ++inline_sym13__) {
+              int inline_sym11__;
+              inline_sym11__ = std::numeric_limits<int>::min();
+              
+              lcm_sym107__ = (n_occasions - inline_sym13__);
+              int inline_sym12__;
+              inline_sym12__ = std::numeric_limits<int>::min();
+              
+              lcm_sym111__ = (lcm_sym107__ + 1);
+              current_statement__ = 18;
+              assign(inline_sym10__,
+                cons_list(index_uni(inline_sym14__),
+                  cons_list(index_uni(lcm_sym107__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(inline_sym14__),
+                       cons_list(index_uni(lcm_sym107__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(inline_sym14__),
+                          cons_list(index_uni((lcm_sym111__ - 1)),
+                            nil_index_list())), "p"))),
+                  rvalue(inline_sym10__,
+                    cons_list(index_uni(inline_sym14__),
+                      cons_list(index_uni(lcm_sym111__), nil_index_list())),
+                    "inline_sym10__"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(inline_sym14__),
+                        cons_list(index_uni(lcm_sym107__), nil_index_list())),
+                      "phi"))), "assigning variable inline_sym10__");}
+          } 
+          if (inline_sym15__) {
+            break;
+          } }
+        if (inline_sym15__) {
+          break;
+        } 
+        inline_sym15__ = 1;
+        assign(inline_sym9__, nil_index_list(), inline_sym10__,
+          "assigning variable inline_sym9__");
+        break;}
+      assign(chi, nil_index_list(), inline_sym9__, "assigning variable chi");
+      current_statement__ = 3;
+      current_statement__ = 3;
+      check_greater_or_equal(function__, "phi", phi, 0);
+      current_statement__ = 3;
+      current_statement__ = 3;
+      check_less_or_equal(function__, "phi", phi, 1);
+      current_statement__ = 4;
+      current_statement__ = 4;
+      check_greater_or_equal(function__, "p", p, 0);
+      current_statement__ = 4;
+      current_statement__ = 4;
+      check_less_or_equal(function__, "p", p, 1);
+      current_statement__ = 5;
+      current_statement__ = 5;
+      check_greater_or_equal(function__, "chi", inline_sym9__, 0);
+      current_statement__ = 5;
+      current_statement__ = 5;
+      check_less_or_equal(function__, "chi", inline_sym9__, 1);
+      {
+        current_statement__ = 28;
+        if (lcm_sym97__) {
+          lcm_sym138__ = rvalue(first,
+                           cons_list(index_uni(1), nil_index_list()),
+                           "first");
+          if (logical_gt(lcm_sym138__, 0)) {
+            lcm_sym140__ = rvalue(last,
+                             cons_list(index_uni(1), nil_index_list()),
+                             "last");
+            lcm_sym116__ = (lcm_sym138__ + 1);
+            if (logical_gte(lcm_sym140__, lcm_sym116__)) {
+              current_statement__ = 22;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(phi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((lcm_sym116__ - 1)),
+                        nil_index_list())), "phi")));
+              lcm_sym114__ = (lcm_sym116__ + 1);
+              lp_accum__.add(
+                bernoulli_log<propto__>(
+                  rvalue(y,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym116__), nil_index_list())),
+                    "y"),
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((lcm_sym116__ - 1)),
+                        nil_index_list())), "p")));
+              for (int t = lcm_sym114__; t <= lcm_sym140__; ++t) {
+                current_statement__ = 22;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(phi,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((t - 1)), nil_index_list())),
+                      "phi")));
+                current_statement__ = 23;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(
+                    rvalue(y,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(t), nil_index_list())), "y"),
+                    rvalue(p,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((t - 1)), nil_index_list())),
+                      "p")));}
+            } 
+            current_statement__ = 25;
+            lp_accum__.add(
+              bernoulli_log<propto__>(1,
+                rvalue(inline_sym9__,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym140__), nil_index_list())),
+                  "inline_sym9__")));
+          } 
+          for (int i = 2; i <= nind; ++i) {
+            lcm_sym137__ = rvalue(first,
+                             cons_list(index_uni(i), nil_index_list()),
+                             "first");
+            if (logical_gt(lcm_sym137__, 0)) {
+              lcm_sym139__ = rvalue(last,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "last");
+              lcm_sym115__ = (lcm_sym137__ + 1);
+              if (logical_gte(lcm_sym139__, lcm_sym115__)) {
+                current_statement__ = 22;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(phi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((lcm_sym115__ - 1)),
+                          nil_index_list())), "phi")));
+                lcm_sym113__ = (lcm_sym115__ + 1);
+                lp_accum__.add(
+                  bernoulli_log<propto__>(
+                    rvalue(y,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym115__), nil_index_list())),
+                      "y"),
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((lcm_sym115__ - 1)),
+                          nil_index_list())), "p")));
+                for (int t = lcm_sym113__; t <= lcm_sym139__; ++t) {
+                  current_statement__ = 22;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(1,
+                      rvalue(phi,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((t - 1)), nil_index_list())),
+                        "phi")));
+                  current_statement__ = 23;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(
+                      rvalue(y,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni(t), nil_index_list())), "y"),
+                      rvalue(p,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((t - 1)), nil_index_list())),
+                        "p")));}
+              } 
+              current_statement__ = 25;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(inline_sym9__,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym139__), nil_index_list())),
+                    "inline_sym9__")));
+            } }
+        } 
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "fails_test_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym95__;
+      double lcm_sym94__;
+      double lcm_sym93__;
+      double lcm_sym92__;
+      double lcm_sym91__;
+      double lcm_sym90__;
+      double lcm_sym89__;
+      double lcm_sym88__;
+      double lcm_sym87__;
+      double lcm_sym86__;
+      double lcm_sym85__;
+      double lcm_sym84__;
+      int lcm_sym83__;
+      int lcm_sym82__;
+      double lcm_sym81__;
+      double lcm_sym80__;
+      double lcm_sym79__;
+      double lcm_sym78__;
+      double lcm_sym77__;
+      double lcm_sym76__;
+      double lcm_sym73__;
+      double lcm_sym72__;
+      int lcm_sym71__;
+      int lcm_sym70__;
+      int lcm_sym69__;
+      int lcm_sym68__;
+      int lcm_sym67__;
+      int lcm_sym66__;
+      int lcm_sym65__;
+      int lcm_sym64__;
+      int lcm_sym63__;
+      int lcm_sym62__;
+      int lcm_sym61__;
+      int lcm_sym60__;
+      int lcm_sym59__;
+      int lcm_sym58__;
+      int lcm_sym57__;
+      int lcm_sym56__;
+      int lcm_sym55__;
+      int lcm_sym54__;
+      double mean_p;
+      mean_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mean_p = in__.scalar();
+      current_statement__ = 1;
+      mean_p = stan::math::lub_constrain(mean_p, 0, 1);
+      current_statement__ = 2;
+      validate_non_negative_index("beta", "max_age", max_age);
+      Eigen::Matrix<double, -1, 1> beta;
+      beta = Eigen::Matrix<double, -1, 1>(max_age);
+      stan::math::fill(beta, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 2;
+      beta = in__.vector(max_age);
+      lcm_sym54__ = logical_gte(max_age, 1);
+      if (lcm_sym54__) {
+        current_statement__ = 2;
+        assign(beta, cons_list(index_uni(1), nil_index_list()),
+          stan::math::lub_constrain(
+            rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+            0, 1), "assigning variable beta");
+        for (int sym1__ = 2; sym1__ <= max_age; ++sym1__) {
+          current_statement__ = 2;
+          assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+            stan::math::lub_constrain(beta[(sym1__ - 1)], 0, 1),
+            "assigning variable beta");}
+      } 
+      current_statement__ = 3;
+      validate_non_negative_index("phi", "nind", nind);
+      lcm_sym63__ = (n_occasions - 1);
+      validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym63__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> phi;
+      phi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, lcm_sym63__);
+      stan::math::fill(phi, DUMMY_VAR__);
+      
+      current_statement__ = 4;
+      validate_non_negative_index("p", "nind", nind);
+      current_statement__ = 4;
+      validate_non_negative_index("p", "n_occ_minus_1", lcm_sym63__);
+      Eigen::Matrix<double, -1, -1> p;
+      p = Eigen::Matrix<double, -1, -1>(nind, lcm_sym63__);
+      stan::math::fill(p, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 5;
+      validate_non_negative_index("chi", "nind", nind);
+      current_statement__ = 5;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      vars__.push_back(mean_p);
+      if (lcm_sym54__) {
+        vars__.push_back(
+          rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"));
+        for (int sym1__ = 2; sym1__ <= max_age; ++sym1__) {
+          vars__.push_back(beta[(sym1__ - 1)]);}
+      } 
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      lcm_sym56__ = logical_gte(nind, 1);
+      if (lcm_sym56__) {
+        lcm_sym83__ = rvalue(first,
+                        cons_list(index_uni(1), nil_index_list()), "first");
+        lcm_sym65__ = (lcm_sym83__ - 1);
+        if (logical_gte(lcm_sym65__, 1)) {
+          current_statement__ = 6;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable phi");
+          current_statement__ = 7;
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable p");
+          for (int t = 2; t <= lcm_sym65__; ++t) {
+            current_statement__ = 6;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 7;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable p");}
+        } 
+        current_statement__ = 12;
+        if (logical_gte(lcm_sym63__, lcm_sym83__)) {
+          current_statement__ = 9;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym83__), nil_index_list())),
+            rvalue(beta,
+              cons_list(
+                index_uni(rvalue(x,
+                            cons_list(index_uni(1),
+                              cons_list(index_uni(lcm_sym83__),
+                                nil_index_list())), "x")), nil_index_list()),
+              "beta"), "assigning variable phi");
+          lcm_sym71__ = (lcm_sym83__ + 1);
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym83__), nil_index_list())), mean_p,
+            "assigning variable p");
+          for (int t = lcm_sym71__; t <= lcm_sym63__; ++t) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())),
+              rvalue(beta,
+                cons_list(
+                  index_uni(rvalue(x,
+                              cons_list(index_uni(1),
+                                cons_list(index_uni(t), nil_index_list())),
+                              "x")), nil_index_list()), "beta"),
+              "assigning variable phi");
+            current_statement__ = 10;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), mean_p,
+              "assigning variable p");}
+        } 
+        for (int i = 2; i <= nind; ++i) {
+          lcm_sym82__ = rvalue(first,
+                          cons_list(index_uni(i), nil_index_list()), "first");
+          lcm_sym64__ = (lcm_sym82__ - 1);
+          if (logical_gte(lcm_sym64__, 1)) {
+            current_statement__ = 6;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 7;
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable p");
+            for (int t = 2; t <= lcm_sym64__; ++t) {
+              current_statement__ = 6;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable phi");
+              current_statement__ = 7;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable p");}
+          } 
+          current_statement__ = 12;
+          if (logical_gte(lcm_sym63__, lcm_sym82__)) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym82__), nil_index_list())),
+              rvalue(beta,
+                cons_list(
+                  index_uni(rvalue(x,
+                              cons_list(index_uni(i),
+                                cons_list(index_uni(lcm_sym82__),
+                                  nil_index_list())), "x")),
+                  nil_index_list()), "beta"), "assigning variable phi");
+            lcm_sym70__ = (lcm_sym82__ + 1);
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym82__), nil_index_list())), mean_p,
+              "assigning variable p");
+            for (int t = lcm_sym70__; t <= lcm_sym63__; ++t) {
+              current_statement__ = 9;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())),
+                rvalue(beta,
+                  cons_list(
+                    index_uni(rvalue(x,
+                                cons_list(index_uni(i),
+                                  cons_list(index_uni(t), nil_index_list())),
+                                "x")), nil_index_list()), "beta"),
+                "assigning variable phi");
+              current_statement__ = 10;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), mean_p,
+                "assigning variable p");}
+          } }
+      } 
+      Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym1__;
+      int inline_sym7__;
+      inline_sym7__ = std::numeric_limits<int>::min();
+      
+      lcm_sym57__ = logical_gte(lcm_sym63__, 1);
+      inline_sym7__ = 0;
+      for (int inline_sym8__ = 1; inline_sym8__ <= 1; ++inline_sym8__) {
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "nind", nind);
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "n_occasions", n_occasions);
+        Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym2__;
+        inline_sym2__ = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+        stan::math::fill(inline_sym2__, DUMMY_VAR__);
+        
+        for (int inline_sym6__ = 1; inline_sym6__ <= nind; ++inline_sym6__) {
+          current_statement__ = 15;
+          assign(inline_sym2__,
+            cons_list(index_uni(inline_sym6__),
+              cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+            "assigning variable inline_sym2__");
+          if (lcm_sym57__) {
+            int inline_sym3__;
+            inline_sym3__ = std::numeric_limits<int>::min();
+            
+            int inline_sym4__;
+            inline_sym4__ = std::numeric_limits<int>::min();
+            
+            lcm_sym69__ = (lcm_sym63__ + 1);
+            current_statement__ = 18;
+            assign(inline_sym2__,
+              cons_list(index_uni(inline_sym6__),
+                cons_list(index_uni(lcm_sym63__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(inline_sym6__),
+                     cons_list(index_uni(lcm_sym63__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(inline_sym6__),
+                        cons_list(index_uni((lcm_sym69__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(inline_sym2__,
+                  cons_list(index_uni(inline_sym6__),
+                    cons_list(index_uni(lcm_sym69__), nil_index_list())),
+                  "inline_sym2__"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(inline_sym6__),
+                      cons_list(index_uni(lcm_sym63__), nil_index_list())),
+                    "phi"))), "assigning variable inline_sym2__");
+            for (int inline_sym5__ = 2; inline_sym5__ <= lcm_sym63__;
+                 ++inline_sym5__) {
+              int inline_sym3__;
+              inline_sym3__ = std::numeric_limits<int>::min();
+              
+              lcm_sym62__ = (n_occasions - inline_sym5__);
+              int inline_sym4__;
+              inline_sym4__ = std::numeric_limits<int>::min();
+              
+              lcm_sym68__ = (lcm_sym62__ + 1);
+              current_statement__ = 18;
+              assign(inline_sym2__,
+                cons_list(index_uni(inline_sym6__),
+                  cons_list(index_uni(lcm_sym62__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(inline_sym6__),
+                       cons_list(index_uni(lcm_sym62__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(inline_sym6__),
+                          cons_list(index_uni((lcm_sym68__ - 1)),
+                            nil_index_list())), "p"))),
+                  rvalue(inline_sym2__,
+                    cons_list(index_uni(inline_sym6__),
+                      cons_list(index_uni(lcm_sym68__), nil_index_list())),
+                    "inline_sym2__"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(inline_sym6__),
+                        cons_list(index_uni(lcm_sym62__), nil_index_list())),
+                      "phi"))), "assigning variable inline_sym2__");}
+          } 
+          if (inline_sym7__) {
+            break;
+          } }
+        if (inline_sym7__) {
+          break;
+        } 
+        inline_sym7__ = 1;
+        assign(inline_sym1__, nil_index_list(), inline_sym2__,
+          "assigning variable inline_sym1__");
+        break;}
+      assign(chi, nil_index_list(), inline_sym1__, "assigning variable chi");
+      if (lcm_sym57__) {
+        if (lcm_sym56__) {
+          vars__.push_back(
+            rvalue(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "phi"));
+          for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+            vars__.push_back(
+              rvalue(phi,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "phi"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= lcm_sym63__; ++sym1__) {
+          if (lcm_sym56__) {
+            vars__.push_back(
+              rvalue(phi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())), "phi"));
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              vars__.push_back(
+                rvalue(phi,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())), "phi"));
+            }
+          } }
+      } 
+      if (lcm_sym57__) {
+        if (lcm_sym56__) {
+          vars__.push_back(
+            rvalue(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "p"));
+          for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+            vars__.push_back(
+              rvalue(p,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "p"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= lcm_sym63__; ++sym1__) {
+          if (lcm_sym56__) {
+            vars__.push_back(
+              rvalue(p,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())), "p"));
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              vars__.push_back(
+                rvalue(p,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())), "p"));}
+          } }
+      } 
+      if (logical_gte(n_occasions, 1)) {
+        if (lcm_sym56__) {
+          vars__.push_back(
+            rvalue(inline_sym1__,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "inline_sym1__"));
+          for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+            vars__.push_back(
+              rvalue(inline_sym1__,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())),
+                "inline_sym1__"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          if (lcm_sym56__) {
+            vars__.push_back(
+              rvalue(inline_sym1__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                "inline_sym1__"));
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              vars__.push_back(
+                rvalue(inline_sym1__,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  "inline_sym1__"));}
+          } }
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym53__;
+      double lcm_sym52__;
+      double lcm_sym51__;
+      double lcm_sym50__;
+      int lcm_sym47__;
+      int lcm_sym46__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double mean_p;
+      mean_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mean_p = context__.vals_r("mean_p")[(1 - 1)];
+      current_statement__ = 1;
+      mean_p = stan::math::lub_free(mean_p, 0, 1);
+      current_statement__ = 2;
+      validate_non_negative_index("beta", "max_age", max_age);
+      Eigen::Matrix<double, -1, 1> beta;
+      beta = Eigen::Matrix<double, -1, 1>(max_age);
+      stan::math::fill(beta, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> beta_flat__;
+        current_statement__ = 2;
+        assign(beta_flat__, nil_index_list(), context__.vals_r("beta"),
+          "assigning variable beta_flat__");
+        current_statement__ = 2;
+        pos__ = 1;
+        lcm_sym46__ = logical_gte(max_age, 1);
+        if (lcm_sym46__) {
+          current_statement__ = 2;
+          assign(beta, cons_list(index_uni(1), nil_index_list()),
+            rvalue(beta_flat__, cons_list(index_uni(1), nil_index_list()),
+              "beta_flat__"), "assigning variable beta");
+          current_statement__ = 2;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= max_age; ++sym1__) {
+            current_statement__ = 2;
+            assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+              beta_flat__[(pos__ - 1)], "assigning variable beta");
+            current_statement__ = 2;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 2;
+      if (lcm_sym46__) {
+        current_statement__ = 2;
+        assign(beta, cons_list(index_uni(1), nil_index_list()),
+          stan::math::lub_free(
+            rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+            0, 1), "assigning variable beta");
+        for (int sym1__ = 2; sym1__ <= max_age; ++sym1__) {
+          current_statement__ = 2;
+          assign(beta, cons_list(index_uni(sym1__), nil_index_list()),
+            stan::math::lub_free(beta[(sym1__ - 1)], 0, 1),
+            "assigning variable beta");}
+      } 
+      vars__.push_back(mean_p);
+      if (lcm_sym46__) {
+        vars__.push_back(
+          rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"));
+        for (int sym1__ = 2; sym1__ <= max_age; ++sym1__) {
+          vars__.push_back(beta[(sym1__ - 1)]);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("mean_p");
+    names__.push_back("beta");
+    names__.push_back("phi");
+    names__.push_back("p");
+    names__.push_back("chi");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(max_age);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(nind);
+    
+    dims__.push_back(n_occ_minus_1);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(nind);
+    
+    dims__.push_back(n_occ_minus_1);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(nind);
+    
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mean_p");
+    for (int sym172__ = 1; sym172__ <= max_age; ++sym172__) {
+      {
+        param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym172__));
+      }}
+    if (emit_transformed_parameters__) {
+      for (int sym172__ = 1; sym172__ <= n_occ_minus_1; ++sym172__) {
+        {
+          for (int sym173__ = 1; sym173__ <= nind; ++sym173__) {
+            {
+              param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym173__) + '.' + std::to_string(sym172__));
+            }}
+        }}
+      for (int sym172__ = 1; sym172__ <= n_occ_minus_1; ++sym172__) {
+        {
+          for (int sym173__ = 1; sym173__ <= nind; ++sym173__) {
+            {
+              param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym173__) + '.' + std::to_string(sym172__));
+            }}
+        }}
+      for (int sym172__ = 1; sym172__ <= n_occasions; ++sym172__) {
+        {
+          for (int sym173__ = 1; sym173__ <= nind; ++sym173__) {
+            {
+              param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym173__) + '.' + std::to_string(sym172__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mean_p");
+    for (int sym172__ = 1; sym172__ <= max_age; ++sym172__) {
+      {
+        param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym172__));
+      }}
+    if (emit_transformed_parameters__) {
+      for (int sym172__ = 1; sym172__ <= n_occ_minus_1; ++sym172__) {
+        {
+          for (int sym173__ = 1; sym173__ <= nind; ++sym173__) {
+            {
+              param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym173__) + '.' + std::to_string(sym172__));
+            }}
+        }}
+      for (int sym172__ = 1; sym172__ <= n_occ_minus_1; ++sym172__) {
+        {
+          for (int sym173__ = 1; sym173__ <= nind; ++sym173__) {
+            {
+              param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym173__) + '.' + std::to_string(sym172__));
+            }}
+        }}
+      for (int sym172__ = 1; sym172__ <= n_occasions; ++sym172__) {
+        {
+          for (int sym173__ = 1; sym173__ <= nind; ++sym173__) {
+            {
+              param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym173__) + '.' + std::to_string(sym172__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << max_age << "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << max_age << "},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef fails_test_model_namespace::fails_test_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp inlining-fail2.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace inlining_fail2_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'inlining-fail2.stan', line 177, column 2 to column 33)",
+                                                      " (in 'inlining-fail2.stan', line 178, column 2 to column 31)",
+                                                      " (in 'inlining-fail2.stan', line 179, column 2 to column 45)",
+                                                      " (in 'inlining-fail2.stan', line 180, column 2 to column 32)",
+                                                      " (in 'inlining-fail2.stan', line 181, column 2 to column 30)",
+                                                      " (in 'inlining-fail2.stan', line 187, column 2 to column 50)",
+                                                      " (in 'inlining-fail2.stan', line 188, column 2 to column 44)",
+                                                      " (in 'inlining-fail2.stan', line 189, column 2 to column 46)",
+                                                      " (in 'inlining-fail2.stan', line 194, column 6 to column 58)",
+                                                      " (in 'inlining-fail2.stan', line 193, column 4 to line 194, column 58)",
+                                                      " (in 'inlining-fail2.stan', line 192, column 2 to line 194, column 58)",
+                                                      " (in 'inlining-fail2.stan', line 49, column 4 to column 24)",
+                                                      " (in 'inlining-fail2.stan', line 50, column 4 to column 30)",
+                                                      " (in 'inlining-fail2.stan', line 51, column 4 to column 35)",
+                                                      " (in 'inlining-fail2.stan', line 54, column 6 to column 32)",
+                                                      " (in 'inlining-fail2.stan', line 56, column 8 to column 37)",
+                                                      " (in 'inlining-fail2.stan', line 57, column 8 to column 32)",
+                                                      " (in 'inlining-fail2.stan', line 59, column 8 to line 60, column 65)",
+                                                      " (in 'inlining-fail2.stan', line 55, column 37 to line 61, column 7)",
+                                                      " (in 'inlining-fail2.stan', line 53, column 23 to line 62, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 48, column 47 to line 64, column 3)",
+                                                      " (in 'inlining-fail2.stan', line 213, column 2 to column 14)",
+                                                      " (in 'inlining-fail2.stan', line 214, column 2 to column 11)",
+                                                      " (in 'inlining-fail2.stan', line 215, column 2 to column 24)",
+                                                      " (in 'inlining-fail2.stan', line 216, column 2 to column 13)",
+                                                      " (in 'inlining-fail2.stan', line 217, column 2 to column 21)",
+                                                      " (in 'inlining-fail2.stan', line 218, column 2 to column 21)",
+                                                      " (in 'inlining-fail2.stan', line 219, column 2 to column 24)",
+                                                      " (in 'inlining-fail2.stan', line 223, column 4 to column 14)",
+                                                      " (in 'inlining-fail2.stan', line 224, column 4 to column 13)",
+                                                      " (in 'inlining-fail2.stan', line 231, column 6 to column 35)",
+                                                      " (in 'inlining-fail2.stan', line 228, column 6 to column 32)",
+                                                      " (in 'inlining-fail2.stan', line 227, column 29 to line 232, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 226, column 4 to column 38)",
+                                                      " (in 'inlining-fail2.stan', line 227, column 4 to line 232, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 222, column 17 to line 233, column 3)",
+                                                      " (in 'inlining-fail2.stan', line 222, column 2 to line 233, column 3)",
+                                                      " (in 'inlining-fail2.stan', line 237, column 4 to column 49)",
+                                                      " (in 'inlining-fail2.stan', line 148, column 4 to column 24)",
+                                                      " (in 'inlining-fail2.stan', line 149, column 4 to column 24)",
+                                                      " (in 'inlining-fail2.stan', line 150, column 4 to column 31)",
+                                                      " (in 'inlining-fail2.stan', line 154, column 6 to column 64)",
+                                                      " (in 'inlining-fail2.stan', line 153, column 6 to column 55)",
+                                                      " (in 'inlining-fail2.stan', line 152, column 19 to line 155, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 147, column 33 to line 157, column 3)",
+                                                      " (in 'inlining-fail2.stan', line 238, column 4 to column 63)",
+                                                      " (in 'inlining-fail2.stan', line 239, column 4 to column 16)",
+                                                      " (in 'inlining-fail2.stan', line 240, column 4 to column 18)",
+                                                      " (in 'inlining-fail2.stan', line 247, column 6 to column 36)",
+                                                      " (in 'inlining-fail2.stan', line 17, column 8 to column 17)",
+                                                      " (in 'inlining-fail2.stan', line 16, column 6 to line 17, column 17)",
+                                                      " (in 'inlining-fail2.stan', line 14, column 31 to line 19, column 3)",
+                                                      " (in 'inlining-fail2.stan', line 250, column 8 to column 26)",
+                                                      " (in 'inlining-fail2.stan', line 249, column 6 to line 250, column 26)",
+                                                      " (in 'inlining-fail2.stan', line 246, column 19 to line 251, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 246, column 4 to line 251, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 253, column 6 to column 25)",
+                                                      " (in 'inlining-fail2.stan', line 254, column 6 to column 31)",
+                                                      " (in 'inlining-fail2.stan', line 252, column 29 to line 255, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 252, column 4 to line 255, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 257, column 6 to column 26)",
+                                                      " (in 'inlining-fail2.stan', line 258, column 6 to column 31)",
+                                                      " (in 'inlining-fail2.stan', line 256, column 19 to line 259, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 256, column 4 to line 259, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 260, column 4 to column 25)",
+                                                      " (in 'inlining-fail2.stan', line 236, column 2 to line 261, column 3)",
+                                                      " (in 'inlining-fail2.stan', line 206, column 2 to column 29)",
+                                                      " (in 'inlining-fail2.stan', line 80, column 4 to column 27)",
+                                                      " (in 'inlining-fail2.stan', line 81, column 4 to column 33)",
+                                                      " (in 'inlining-fail2.stan', line 82, column 4 to column 45)",
+                                                      " (in 'inlining-fail2.stan', line 85, column 6 to column 43)",
+                                                      " (in 'inlining-fail2.stan', line 119, column 8 to column 33)",
+                                                      " (in 'inlining-fail2.stan', line 127, column 10 to line 130, column 49)",
+                                                      " (in 'inlining-fail2.stan', line 132, column 8 to column 63)",
+                                                      " (in 'inlining-fail2.stan', line 133, column 8 to column 34)",
+                                                      " (in 'inlining-fail2.stan', line 118, column 13 to line 134, column 7)",
+                                                      " (in 'inlining-fail2.stan', line 92, column 10 to column 30)",
+                                                      " (in 'inlining-fail2.stan', line 101, column 12 to line 105, column 56)",
+                                                      " (in 'inlining-fail2.stan', line 106, column 10 to line 108, column 61)",
+                                                      " (in 'inlining-fail2.stan', line 109, column 10 to column 36)",
+                                                      " (in 'inlining-fail2.stan', line 91, column 15 to line 110, column 9)",
+                                                      " (in 'inlining-fail2.stan', line 89, column 27 to line 91, column 9)",
+                                                      " (in 'inlining-fail2.stan', line 89, column 8 to line 110, column 9)",
+                                                      " (in 'inlining-fail2.stan', line 113, column 10 to column 39)",
+                                                      " (in 'inlining-fail2.stan', line 114, column 10 to column 39)",
+                                                      " (in 'inlining-fail2.stan', line 112, column 42 to line 115, column 9)",
+                                                      " (in 'inlining-fail2.stan', line 117, column 8 to column 39)",
+                                                      " (in 'inlining-fail2.stan', line 87, column 20 to line 118, column 7)",
+                                                      " (in 'inlining-fail2.stan', line 122, column 8 to line 124, column 47)",
+                                                      " (in 'inlining-fail2.stan', line 90, column 10 to column 44)",
+                                                      " (in 'inlining-fail2.stan', line 84, column 23 to line 135, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 161, column 2 to column 17)",
+                                                      " (in 'inlining-fail2.stan', line 162, column 2 to column 27)",
+                                                      " (in 'inlining-fail2.stan', line 163, column 2 to column 41)",
+                                                      " (in 'inlining-fail2.stan', line 167, column 2 to column 42)",
+                                                      " (in 'inlining-fail2.stan', line 168, column 2 to column 41)",
+                                                      " (in 'inlining-fail2.stan', line 171, column 4 to column 35)",
+                                                      " (in 'inlining-fail2.stan', line 170, column 2 to line 171, column 35)",
+                                                      " (in 'inlining-fail2.stan', line 30, column 6 to column 32)",
+                                                      " (in 'inlining-fail2.stan', line 33, column 8 to column 17)",
+                                                      " (in 'inlining-fail2.stan', line 32, column 6 to line 33, column 17)",
+                                                      " (in 'inlining-fail2.stan', line 29, column 37 to line 34, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 28, column 30 to line 36, column 3)",
+                                                      " (in 'inlining-fail2.stan', line 173, column 4 to column 33)",
+                                                      " (in 'inlining-fail2.stan', line 172, column 2 to line 173, column 33)",
+                                                      " (in 'inlining-fail2.stan', line 18, column 4 to column 13)",
+                                                      " (in 'inlining-fail2.stan', line 35, column 4 to column 13)",
+                                                      " (in 'inlining-fail2.stan', line 55, column 6 to line 61, column 7)",
+                                                      " (in 'inlining-fail2.stan', line 53, column 4 to line 62, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 63, column 4 to column 15)",
+                                                      " (in 'inlining-fail2.stan', line 126, column 8 to line 130, column 49)",
+                                                      " (in 'inlining-fail2.stan', line 100, column 10 to line 105, column 56)",
+                                                      " (in 'inlining-fail2.stan', line 84, column 4 to line 135, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 79, column 34 to line 136, column 3)",
+                                                      " (in 'inlining-fail2.stan', line 152, column 4 to line 155, column 5)",
+                                                      " (in 'inlining-fail2.stan', line 156, column 4 to column 26)"};
+
+
+int
+first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym53__;
+    int lcm_sym52__;
+    int lcm_sym51__;
+    int lcm_sym50__;
+    {
+      lcm_sym51__ = size(y_i);
+      if (logical_gte(lcm_sym51__, 1)) {
+        current_statement__ = 51;
+        if (rvalue(y_i, cons_list(index_uni(1), nil_index_list()), "y_i")) {
+          current_statement__ = 50;
+          return 1;
+        } 
+        for (int k = 2; k <= lcm_sym51__; ++k) {
+          current_statement__ = 51;
+          if (rvalue(y_i, cons_list(index_uni(k), nil_index_list()), "y_i")) {
+            current_statement__ = 50;
+            return k;
+          } }
+      } 
+      current_statement__ = 106;
+      return 0;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct first_capture_functor__ {
+int
+operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+{
+return first_capture(y_i, pstream__);
+}
+};
+
+int
+last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym59__;
+    int lcm_sym58__;
+    int lcm_sym57__;
+    int lcm_sym56__;
+    int lcm_sym55__;
+    int lcm_sym54__;
+    {
+      lcm_sym57__ = (size(y_i) - 1);
+      if (logical_gte(lcm_sym57__, 0)) {
+        int k;
+        k = std::numeric_limits<int>::min();
+        
+        lcm_sym56__ = (size(y_i) - 0);
+        current_statement__ = 101;
+        if (y_i[(lcm_sym56__ - 1)]) {
+          current_statement__ = 100;
+          return lcm_sym56__;
+        } 
+        for (int k_rev = 1; k_rev <= lcm_sym57__; ++k_rev) {
+          int k;
+          k = std::numeric_limits<int>::min();
+          
+          lcm_sym55__ = (size(y_i) - k_rev);
+          current_statement__ = 101;
+          if (y_i[(lcm_sym55__ - 1)]) {
+            current_statement__ = 100;
+            return lcm_sym55__;
+          } }
+      } 
+      current_statement__ = 107;
+      return 0;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct last_capture_functor__ {
+int
+operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+{
+return last_capture(y_i, pstream__);
+}
+};
+
+template <typename T0__, typename T1__>
+Eigen::Matrix<stan::promote_args_t<T0__,
+T1__>, -1, -1>
+prob_uncaptured(const Eigen::Matrix<T0__, -1, -1>& p,
+                const Eigen::Matrix<T1__, -1, -1>& phi,
+                std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<T0__, T1__>;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym71__;
+    double lcm_sym70__;
+    double lcm_sym69__;
+    double lcm_sym68__;
+    double lcm_sym67__;
+    int lcm_sym66__;
+    int lcm_sym65__;
+    int lcm_sym64__;
+    int lcm_sym63__;
+    int lcm_sym62__;
+    int lcm_sym61__;
+    int lcm_sym60__;
+    {
+      int n_ind;
+      n_ind = std::numeric_limits<int>::min();
+      
+      lcm_sym71__ = rows(p);
+      int n_occasions;
+      n_occasions = std::numeric_limits<int>::min();
+      
+      lcm_sym66__ = cols(p);
+      n_occasions = lcm_sym66__;
+      current_statement__ = 14;
+      validate_non_negative_index("chi", "n_ind", lcm_sym71__);
+      current_statement__ = 14;
+      validate_non_negative_index("chi", "n_occasions", lcm_sym66__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(lcm_sym71__, lcm_sym66__);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      current_statement__ = 109;
+      if (logical_gte(lcm_sym71__, 1)) {
+        current_statement__ = 15;
+        assign(chi,
+          cons_list(index_uni(1),
+            cons_list(index_uni(lcm_sym66__), nil_index_list())), 1.0,
+          "assigning variable chi");
+        lcm_sym63__ = (lcm_sym66__ - 1);
+        lcm_sym60__ = logical_gte(lcm_sym63__, 1);
+        if (lcm_sym60__) {
+          int t_curr;
+          t_curr = std::numeric_limits<int>::min();
+          
+          int t_next;
+          t_next = std::numeric_limits<int>::min();
+          
+          lcm_sym65__ = (lcm_sym63__ + 1);
+          current_statement__ = 18;
+          assign(chi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym63__), nil_index_list())),
+            stan::math::fma(
+              (rvalue(phi,
+                 cons_list(index_uni(1),
+                   cons_list(index_uni(lcm_sym63__), nil_index_list())),
+                 "phi") *
+                (1 -
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym65__), nil_index_list())),
+                    "p"))),
+              rvalue(chi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(lcm_sym65__), nil_index_list())),
+                "chi"),
+              (1 -
+                rvalue(phi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym63__), nil_index_list())),
+                  "phi"))), "assigning variable chi");
+          for (int t = 2; t <= lcm_sym63__; ++t) {
+            int t_curr;
+            t_curr = std::numeric_limits<int>::min();
+            
+            lcm_sym62__ = (lcm_sym66__ - t);
+            int t_next;
+            t_next = std::numeric_limits<int>::min();
+            
+            lcm_sym64__ = (lcm_sym62__ + 1);
+            current_statement__ = 18;
+            assign(chi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(lcm_sym62__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(1),
+                     cons_list(index_uni(lcm_sym62__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(lcm_sym64__), nil_index_list())),
+                      "p"))),
+                rvalue(chi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym64__), nil_index_list())),
+                  "chi"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym62__), nil_index_list())),
+                    "phi"))), "assigning variable chi");}
+        } 
+        for (int i = 2; i <= lcm_sym71__; ++i) {
+          current_statement__ = 15;
+          assign(chi,
+            cons_list(index_uni(i),
+              cons_list(index_uni(lcm_sym66__), nil_index_list())), 1.0,
+            "assigning variable chi");
+          current_statement__ = 108;
+          if (lcm_sym60__) {
+            int t_curr;
+            t_curr = std::numeric_limits<int>::min();
+            
+            int t_next;
+            t_next = std::numeric_limits<int>::min();
+            
+            lcm_sym65__ = (lcm_sym63__ + 1);
+            current_statement__ = 18;
+            assign(chi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym63__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(i),
+                     cons_list(index_uni(lcm_sym63__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym65__), nil_index_list())),
+                      "p"))),
+                rvalue(chi,
+                  cons_list(index_uni(i),
+                    cons_list(index_uni(lcm_sym65__), nil_index_list())),
+                  "chi"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym63__), nil_index_list())),
+                    "phi"))), "assigning variable chi");
+            for (int t = 2; t <= lcm_sym63__; ++t) {
+              int t_curr;
+              t_curr = std::numeric_limits<int>::min();
+              
+              lcm_sym62__ = (lcm_sym66__ - t);
+              int t_next;
+              t_next = std::numeric_limits<int>::min();
+              
+              lcm_sym64__ = (lcm_sym62__ + 1);
+              current_statement__ = 18;
+              assign(chi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(lcm_sym62__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(i),
+                       cons_list(index_uni(lcm_sym62__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni(lcm_sym64__), nil_index_list())),
+                        "p"))),
+                  rvalue(chi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym64__), nil_index_list())),
+                    "chi"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym62__), nil_index_list())),
+                      "phi"))), "assigning variable chi");}
+          } }
+      } 
+      current_statement__ = 110;
+      return chi;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct prob_uncaptured_functor__ {
+template <typename T0__, typename T1__>
+Eigen::Matrix<stan::promote_args_t<T0__,
+T1__>, -1, -1>
+operator()(const Eigen::Matrix<T0__, -1, -1>& p,
+           const Eigen::Matrix<T1__, -1, -1>& phi, std::ostream* pstream__)  const 
+{
+return prob_uncaptured(p, phi, pstream__);
+}
+};
+
+template <bool propto__, typename T3__, typename T4__, typename T5__,
+typename T6__, typename T_lp__, typename T_lp_accum__>
+void
+jolly_seber_lp(const std::vector<std::vector<int>>& y,
+               const std::vector<int>& first, const std::vector<int>& last,
+               const Eigen::Matrix<T3__, -1, -1>& p,
+               const Eigen::Matrix<T4__, -1, -1>& phi,
+               const Eigen::Matrix<T5__, -1, 1>& gamma,
+               const Eigen::Matrix<T6__, -1, -1>& chi, T_lp__& lp__,
+               T_lp_accum__& lp_accum__, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<T3__, T4__, T5__, T6__>;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym121__;
+    int lcm_sym120__;
+    int lcm_sym119__;
+    int lcm_sym118__;
+    int lcm_sym117__;
+    int lcm_sym116__;
+    double lcm_sym115__;
+    double lcm_sym114__;
+    double lcm_sym113__;
+    double lcm_sym112__;
+    double lcm_sym111__;
+    double lcm_sym110__;
+    double lcm_sym109__;
+    double lcm_sym108__;
+    double lcm_sym107__;
+    double lcm_sym106__;
+    double lcm_sym105__;
+    double lcm_sym104__;
+    double lcm_sym103__;
+    double lcm_sym102__;
+    int lcm_sym101__;
+    int lcm_sym100__;
+    int lcm_sym99__;
+    double lcm_sym98__;
+    double lcm_sym97__;
+    double lcm_sym96__;
+    double lcm_sym95__;
+    double lcm_sym94__;
+    double lcm_sym93__;
+    double lcm_sym92__;
+    double lcm_sym91__;
+    double lcm_sym90__;
+    double lcm_sym89__;
+    double lcm_sym88__;
+    double lcm_sym87__;
+    double lcm_sym86__;
+    double lcm_sym85__;
+    int lcm_sym84__;
+    int lcm_sym83__;
+    Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym82__;
+    Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym81__;
+    Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym80__;
+    int lcm_sym79__;
+    int lcm_sym78__;
+    int lcm_sym77__;
+    int lcm_sym76__;
+    int lcm_sym75__;
+    int lcm_sym74__;
+    int lcm_sym73__;
+    int lcm_sym72__;
+    {
+      int n_ind;
+      n_ind = std::numeric_limits<int>::min();
+      
+      lcm_sym120__ = rvalue(dims(y),
+                       cons_list(index_uni(1), nil_index_list()), "dims(y)");
+      int n_occasions;
+      n_occasions = std::numeric_limits<int>::min();
+      
+      lcm_sym121__ = rvalue(dims(y),
+                       cons_list(index_uni(2), nil_index_list()), "dims(y)");
+      n_occasions = lcm_sym121__;
+      current_statement__ = 70;
+      validate_non_negative_index("qgamma", "n_occasions", lcm_sym121__);
+      Eigen::Matrix<double, -1, 1> qgamma;
+      qgamma = Eigen::Matrix<double, -1, 1>(lcm_sym121__);
+      stan::math::fill(qgamma, std::numeric_limits<double>::quiet_NaN());
+      
+      assign(lcm_sym80__, nil_index_list(), subtract(1.0, gamma),
+        "assigning variable lcm_sym80__");
+      current_statement__ = 113;
+      if (logical_gte(lcm_sym120__, 1)) {
+        current_statement__ = 71;
+        validate_non_negative_index("qp", "n_occasions", lcm_sym121__);
+        Eigen::Matrix<double, -1, 1> qp;
+        qp = Eigen::Matrix<double, -1, 1>(lcm_sym121__);
+        stan::math::fill(qp, std::numeric_limits<double>::quiet_NaN());
+        
+        assign(lcm_sym82__, nil_index_list(),
+          subtract(1.0,
+            transpose(
+              rvalue(p, cons_list(index_uni(1), nil_index_list()), "p"))),
+          "assigning variable lcm_sym82__");
+        lcm_sym117__ = rvalue(first,
+                         cons_list(index_uni(1), nil_index_list()), "first");
+        if (lcm_sym117__) {
+          current_statement__ = 83;
+          if (logical_eq(lcm_sym117__, 1)) {
+            current_statement__ = 90;
+            lp_accum__.add(
+              bernoulli_log<propto__>(1,
+                (rvalue(gamma, cons_list(index_uni(1), nil_index_list()),
+                   "gamma") *
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(1), nil_index_list())), "p"))));
+          } else {
+            current_statement__ = 77;
+            validate_non_negative_index("lp",
+                                        "rvalue(first, cons_list(index_uni(i), nil_index_list()), \"first\")",
+                                        lcm_sym117__);
+            Eigen::Matrix<local_scalar_t__, -1, 1> lp;
+            lp = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym117__);
+            stan::math::fill(lp, DUMMY_VAR__);
+            
+            lcm_sym84__ = (lcm_sym117__ - 1);
+            assign(lp, cons_list(index_uni(1), nil_index_list()),
+              (((bernoulli_lpmf<false>(1,
+                   rvalue(gamma, cons_list(index_uni(1), nil_index_list()),
+                     "gamma")) +
+                  bernoulli_lpmf<false>(1,
+                    prod(
+                      rvalue(lcm_sym82__,
+                        cons_list(index_min_max(1, lcm_sym84__),
+                          nil_index_list()), "lcm_sym82__")))) +
+                 bernoulli_lpmf<false>(1,
+                   prod(
+                     rvalue(phi,
+                       cons_list(index_uni(1),
+                         cons_list(index_min_max(1, lcm_sym84__),
+                           nil_index_list())), "phi")))) +
+                bernoulli_lpmf<false>(1,
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym117__), nil_index_list())),
+                    "p"))), "assigning variable lp");
+            current_statement__ = 112;
+            if (logical_gte(lcm_sym84__, 2)) {
+              current_statement__ = 78;
+              assign(lp, cons_list(index_uni(2), nil_index_list()),
+                ((((bernoulli_lpmf<false>(1,
+                      prod(
+                        rvalue(lcm_sym80__,
+                          cons_list(index_min_max(1, 1), nil_index_list()),
+                          "lcm_sym80__"))) +
+                     bernoulli_lpmf<false>(1,
+                       rvalue(gamma,
+                         cons_list(index_uni(2), nil_index_list()), "gamma")))
+                    +
+                    bernoulli_lpmf<false>(1,
+                      prod(
+                        rvalue(lcm_sym82__,
+                          cons_list(index_min_max(2, lcm_sym84__),
+                            nil_index_list()), "lcm_sym82__")))) +
+                   bernoulli_lpmf<false>(1,
+                     prod(
+                       rvalue(phi,
+                         cons_list(index_uni(1),
+                           cons_list(index_min_max(2, lcm_sym84__),
+                             nil_index_list())), "phi")))) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(p,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(lcm_sym117__), nil_index_list())),
+                      "p"))), "assigning variable lp");
+              for (int t = 3; t <= lcm_sym84__; ++t) {
+                current_statement__ = 78;
+                assign(lp, cons_list(index_uni(t), nil_index_list()),
+                  ((((bernoulli_lpmf<false>(1,
+                        prod(
+                          rvalue(lcm_sym80__,
+                            cons_list(index_min_max(1, (t - 1)),
+                              nil_index_list()), "lcm_sym80__"))) +
+                       bernoulli_lpmf<false>(1,
+                         rvalue(gamma,
+                           cons_list(index_uni(t), nil_index_list()),
+                           "gamma"))) +
+                      bernoulli_lpmf<false>(1,
+                        prod(
+                          rvalue(lcm_sym82__,
+                            cons_list(index_min_max(t, lcm_sym84__),
+                              nil_index_list()), "lcm_sym82__")))) +
+                     bernoulli_lpmf<false>(1,
+                       prod(
+                         rvalue(phi,
+                           cons_list(index_uni(1),
+                             cons_list(index_min_max(t, lcm_sym84__),
+                               nil_index_list())), "phi")))) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(p,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(lcm_sym117__),
+                            nil_index_list())), "p"))),
+                  "assigning variable lp");}
+            } 
+            current_statement__ = 79;
+            assign(lp, cons_list(index_uni(lcm_sym117__), nil_index_list()),
+              ((bernoulli_lpmf<false>(1,
+                  prod(
+                    rvalue(lcm_sym80__,
+                      cons_list(index_min_max(1, lcm_sym84__),
+                        nil_index_list()), "lcm_sym80__"))) +
+                 bernoulli_lpmf<false>(1, gamma[(lcm_sym117__ - 1)])) +
+                bernoulli_lpmf<false>(1,
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym117__), nil_index_list())),
+                    "p"))), "assigning variable lp");
+            current_statement__ = 80;
+            lp_accum__.add(log_sum_exp(lp));
+          }
+          lcm_sym119__ = rvalue(last,
+                           cons_list(index_uni(1), nil_index_list()), "last");
+          if (logical_gte(lcm_sym119__, (lcm_sym117__ + 1))) {
+            current_statement__ = 84;
+            lp_accum__.add(
+              bernoulli_log<propto__>(1,
+                rvalue(phi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(((lcm_sym117__ + 1) - 1)),
+                      nil_index_list())), "phi")));
+            lcm_sym100__ = ((lcm_sym117__ + 1) + 1);
+            lp_accum__.add(
+              bernoulli_log<propto__>(
+                rvalue(y,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni((lcm_sym117__ + 1)),
+                      nil_index_list())), "y"),
+                rvalue(p,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni((lcm_sym117__ + 1)),
+                      nil_index_list())), "p")));
+            for (int t = lcm_sym100__; t <= lcm_sym119__; ++t) {
+              current_statement__ = 84;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(phi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((t - 1)), nil_index_list())),
+                    "phi")));
+              current_statement__ = 85;
+              lp_accum__.add(
+                bernoulli_log<propto__>(
+                  rvalue(y,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(t), nil_index_list())), "y"),
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(t), nil_index_list())), "p")));}
+          } 
+          current_statement__ = 87;
+          lp_accum__.add(
+            bernoulli_log<propto__>(1,
+              rvalue(chi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(lcm_sym119__), nil_index_list())),
+                "chi")));
+        } else {
+          lcm_sym101__ = (lcm_sym121__ + 1);
+          validate_non_negative_index("lp", "(n_occasions + 1)", lcm_sym101__);
+          Eigen::Matrix<local_scalar_t__, -1, 1> lp;
+          lp = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym101__);
+          stan::math::fill(lp, DUMMY_VAR__);
+          
+          current_statement__ = 89;
+          assign(lp, cons_list(index_uni(1), nil_index_list()),
+            ((bernoulli_lpmf<false>(1,
+                rvalue(gamma, cons_list(index_uni(1), nil_index_list()),
+                  "gamma")) +
+               bernoulli_lpmf<false>(0,
+                 rvalue(p,
+                   cons_list(index_uni(1),
+                     cons_list(index_uni(1), nil_index_list())), "p"))) +
+              bernoulli_lpmf<false>(1,
+                rvalue(chi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(1), nil_index_list())), "chi"))),
+            "assigning variable lp");
+          current_statement__ = 111;
+          if (logical_gte(lcm_sym121__, 2)) {
+            current_statement__ = 73;
+            assign(lp, cons_list(index_uni(2), nil_index_list()),
+              (((bernoulli_lpmf<false>(1,
+                   prod(
+                     rvalue(lcm_sym80__,
+                       cons_list(index_min_max(1, 1), nil_index_list()),
+                       "lcm_sym80__"))) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(gamma, cons_list(index_uni(2), nil_index_list()),
+                      "gamma"))) +
+                 bernoulli_lpmf<false>(0,
+                   rvalue(p,
+                     cons_list(index_uni(1),
+                       cons_list(index_uni(2), nil_index_list())), "p"))) +
+                bernoulli_lpmf<false>(1,
+                  rvalue(chi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(2), nil_index_list())), "chi"))),
+              "assigning variable lp");
+            for (int t = 3; t <= lcm_sym121__; ++t) {
+              current_statement__ = 73;
+              assign(lp, cons_list(index_uni(t), nil_index_list()),
+                (((bernoulli_lpmf<false>(1,
+                     prod(
+                       rvalue(lcm_sym80__,
+                         cons_list(index_min_max(1, (t - 1)),
+                           nil_index_list()), "lcm_sym80__"))) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(gamma,
+                        cons_list(index_uni(t), nil_index_list()), "gamma")))
+                   +
+                   bernoulli_lpmf<false>(0,
+                     rvalue(p,
+                       cons_list(index_uni(1),
+                         cons_list(index_uni(t), nil_index_list())), "p"))) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(chi,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(t), nil_index_list())), "chi"))),
+                "assigning variable lp");}
+          } 
+          current_statement__ = 74;
+          assign(lp, cons_list(index_uni(lcm_sym101__), nil_index_list()),
+            bernoulli_lpmf<false>(1, prod(lcm_sym80__)),
+            "assigning variable lp");
+          current_statement__ = 75;
+          lp_accum__.add(log_sum_exp(lp));
+        }
+        for (int i = 2; i <= lcm_sym120__; ++i) {
+          current_statement__ = 71;
+          validate_non_negative_index("qp", "n_occasions", lcm_sym121__);
+          Eigen::Matrix<double, -1, 1> qp;
+          qp = Eigen::Matrix<double, -1, 1>(lcm_sym121__);
+          stan::math::fill(qp, std::numeric_limits<double>::quiet_NaN());
+          
+          assign(lcm_sym81__, nil_index_list(),
+            subtract(1.0,
+              transpose(
+                rvalue(p, cons_list(index_uni(i), nil_index_list()), "p"))),
+            "assigning variable lcm_sym81__");
+          lcm_sym116__ = rvalue(first,
+                           cons_list(index_uni(i), nil_index_list()),
+                           "first");
+          if (lcm_sym116__) {
+            current_statement__ = 83;
+            if (logical_eq(lcm_sym116__, 1)) {
+              current_statement__ = 90;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  (rvalue(gamma, cons_list(index_uni(1), nil_index_list()),
+                     "gamma") *
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(1), nil_index_list())), "p"))));
+            } else {
+              current_statement__ = 77;
+              validate_non_negative_index("lp",
+                                          "rvalue(first, cons_list(index_uni(i), nil_index_list()), \"first\")",
+                                          lcm_sym116__);
+              Eigen::Matrix<local_scalar_t__, -1, 1> lp;
+              lp = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym116__);
+              stan::math::fill(lp, DUMMY_VAR__);
+              
+              lcm_sym83__ = (lcm_sym116__ - 1);
+              assign(lp, cons_list(index_uni(1), nil_index_list()),
+                (((bernoulli_lpmf<false>(1,
+                     rvalue(gamma, cons_list(index_uni(1), nil_index_list()),
+                       "gamma")) +
+                    bernoulli_lpmf<false>(1,
+                      prod(
+                        rvalue(lcm_sym81__,
+                          cons_list(index_min_max(1, lcm_sym83__),
+                            nil_index_list()), "lcm_sym81__")))) +
+                   bernoulli_lpmf<false>(1,
+                     prod(
+                       rvalue(phi,
+                         cons_list(index_uni(i),
+                           cons_list(index_min_max(1, lcm_sym83__),
+                             nil_index_list())), "phi")))) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym116__), nil_index_list())),
+                      "p"))), "assigning variable lp");
+              current_statement__ = 112;
+              if (logical_gte(lcm_sym83__, 2)) {
+                current_statement__ = 78;
+                assign(lp, cons_list(index_uni(2), nil_index_list()),
+                  ((((bernoulli_lpmf<false>(1,
+                        prod(
+                          rvalue(lcm_sym80__,
+                            cons_list(index_min_max(1, 1), nil_index_list()),
+                            "lcm_sym80__"))) +
+                       bernoulli_lpmf<false>(1,
+                         rvalue(gamma,
+                           cons_list(index_uni(2), nil_index_list()),
+                           "gamma"))) +
+                      bernoulli_lpmf<false>(1,
+                        prod(
+                          rvalue(lcm_sym81__,
+                            cons_list(index_min_max(2, lcm_sym83__),
+                              nil_index_list()), "lcm_sym81__")))) +
+                     bernoulli_lpmf<false>(1,
+                       prod(
+                         rvalue(phi,
+                           cons_list(index_uni(i),
+                             cons_list(index_min_max(2, lcm_sym83__),
+                               nil_index_list())), "phi")))) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(p,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni(lcm_sym116__),
+                            nil_index_list())), "p"))),
+                  "assigning variable lp");
+                for (int t = 3; t <= lcm_sym83__; ++t) {
+                  current_statement__ = 78;
+                  assign(lp, cons_list(index_uni(t), nil_index_list()),
+                    ((((bernoulli_lpmf<false>(1,
+                          prod(
+                            rvalue(lcm_sym80__,
+                              cons_list(index_min_max(1, (t - 1)),
+                                nil_index_list()), "lcm_sym80__"))) +
+                         bernoulli_lpmf<false>(1,
+                           rvalue(gamma,
+                             cons_list(index_uni(t), nil_index_list()),
+                             "gamma"))) +
+                        bernoulli_lpmf<false>(1,
+                          prod(
+                            rvalue(lcm_sym81__,
+                              cons_list(index_min_max(t, lcm_sym83__),
+                                nil_index_list()), "lcm_sym81__")))) +
+                       bernoulli_lpmf<false>(1,
+                         prod(
+                           rvalue(phi,
+                             cons_list(index_uni(i),
+                               cons_list(index_min_max(t, lcm_sym83__),
+                                 nil_index_list())), "phi")))) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(p,
+                          cons_list(index_uni(i),
+                            cons_list(index_uni(lcm_sym116__),
+                              nil_index_list())), "p"))),
+                    "assigning variable lp");}
+              } 
+              current_statement__ = 79;
+              assign(lp,
+                cons_list(index_uni(lcm_sym116__), nil_index_list()),
+                ((bernoulli_lpmf<false>(1,
+                    prod(
+                      rvalue(lcm_sym80__,
+                        cons_list(index_min_max(1, lcm_sym83__),
+                          nil_index_list()), "lcm_sym80__"))) +
+                   bernoulli_lpmf<false>(1, gamma[(lcm_sym116__ - 1)])) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym116__), nil_index_list())),
+                      "p"))), "assigning variable lp");
+              current_statement__ = 80;
+              lp_accum__.add(log_sum_exp(lp));
+            }
+            lcm_sym118__ = rvalue(last,
+                             cons_list(index_uni(i), nil_index_list()),
+                             "last");
+            if (logical_gte(lcm_sym118__, (lcm_sym116__ + 1))) {
+              current_statement__ = 84;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(phi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(((lcm_sym116__ + 1) - 1)),
+                        nil_index_list())), "phi")));
+              lcm_sym99__ = ((lcm_sym116__ + 1) + 1);
+              lp_accum__.add(
+                bernoulli_log<propto__>(
+                  rvalue(y,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni((lcm_sym116__ + 1)),
+                        nil_index_list())), "y"),
+                  rvalue(p,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni((lcm_sym116__ + 1)),
+                        nil_index_list())), "p")));
+              for (int t = lcm_sym99__; t <= lcm_sym118__; ++t) {
+                current_statement__ = 84;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(phi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((t - 1)), nil_index_list())),
+                      "phi")));
+                current_statement__ = 85;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(
+                    rvalue(y,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(t), nil_index_list())), "y"),
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(t), nil_index_list())), "p")));}
+            } 
+            current_statement__ = 87;
+            lp_accum__.add(
+              bernoulli_log<propto__>(1,
+                rvalue(chi,
+                  cons_list(index_uni(i),
+                    cons_list(index_uni(lcm_sym118__), nil_index_list())),
+                  "chi")));
+          } else {
+            lcm_sym101__ = (lcm_sym121__ + 1);
+            validate_non_negative_index("lp", "(n_occasions + 1)",
+                                        lcm_sym101__);
+            Eigen::Matrix<local_scalar_t__, -1, 1> lp;
+            lp = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym101__);
+            stan::math::fill(lp, DUMMY_VAR__);
+            
+            current_statement__ = 89;
+            assign(lp, cons_list(index_uni(1), nil_index_list()),
+              ((bernoulli_lpmf<false>(1,
+                  rvalue(gamma, cons_list(index_uni(1), nil_index_list()),
+                    "gamma")) +
+                 bernoulli_lpmf<false>(0,
+                   rvalue(p,
+                     cons_list(index_uni(i),
+                       cons_list(index_uni(1), nil_index_list())), "p"))) +
+                bernoulli_lpmf<false>(1,
+                  rvalue(chi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(1), nil_index_list())), "chi"))),
+              "assigning variable lp");
+            current_statement__ = 111;
+            if (logical_gte(lcm_sym121__, 2)) {
+              current_statement__ = 73;
+              assign(lp, cons_list(index_uni(2), nil_index_list()),
+                (((bernoulli_lpmf<false>(1,
+                     prod(
+                       rvalue(lcm_sym80__,
+                         cons_list(index_min_max(1, 1), nil_index_list()),
+                         "lcm_sym80__"))) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(gamma,
+                        cons_list(index_uni(2), nil_index_list()), "gamma")))
+                   +
+                   bernoulli_lpmf<false>(0,
+                     rvalue(p,
+                       cons_list(index_uni(i),
+                         cons_list(index_uni(2), nil_index_list())), "p"))) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(chi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(2), nil_index_list())), "chi"))),
+                "assigning variable lp");
+              for (int t = 3; t <= lcm_sym121__; ++t) {
+                current_statement__ = 73;
+                assign(lp, cons_list(index_uni(t), nil_index_list()),
+                  (((bernoulli_lpmf<false>(1,
+                       prod(
+                         rvalue(lcm_sym80__,
+                           cons_list(index_min_max(1, (t - 1)),
+                             nil_index_list()), "lcm_sym80__"))) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(gamma,
+                          cons_list(index_uni(t), nil_index_list()), "gamma")))
+                     +
+                     bernoulli_lpmf<false>(0,
+                       rvalue(p,
+                         cons_list(index_uni(i),
+                           cons_list(index_uni(t), nil_index_list())), "p")))
+                    +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(chi,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni(t), nil_index_list())), "chi"))),
+                  "assigning variable lp");}
+            } 
+            current_statement__ = 74;
+            assign(lp, cons_list(index_uni(lcm_sym101__), nil_index_list()),
+              bernoulli_lpmf<false>(1, prod(lcm_sym80__)),
+              "assigning variable lp");
+            current_statement__ = 75;
+            lp_accum__.add(log_sum_exp(lp));
+          }}
+      } 
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct jolly_seber_lp_functor__ {
+template <bool propto__, typename T3__, typename T4__, typename T5__,
+typename T6__, typename T_lp__, typename T_lp_accum__>
+void
+operator()(const std::vector<std::vector<int>>& y,
+           const std::vector<int>& first, const std::vector<int>& last,
+           const Eigen::Matrix<T3__, -1, -1>& p,
+           const Eigen::Matrix<T4__, -1, -1>& phi,
+           const Eigen::Matrix<T5__, -1, 1>& gamma,
+           const Eigen::Matrix<T6__, -1, -1>& chi, T_lp__& lp__,
+           T_lp_accum__& lp_accum__, std::ostream* pstream__)  const 
+{
+return jolly_seber_lp(y, first, last, p, phi, gamma, chi, lp__, lp_accum__,
+         pstream__);
+}
+};
+
+template <typename T0__>
+Eigen::Matrix<stan::promote_args_t<T0__>, -1, 1>
+seq_cprob(const Eigen::Matrix<T0__, -1, 1>& gamma, std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym128__;
+    Eigen::Matrix<double, -1, 1> lcm_sym127__;
+    double lcm_sym126__;
+    double lcm_sym125__;
+    double lcm_sym124__;
+    double lcm_sym123__;
+    int lcm_sym122__;
+    {
+      int N;
+      N = std::numeric_limits<int>::min();
+      
+      lcm_sym128__ = rows(gamma);
+      N = lcm_sym128__;
+      current_statement__ = 40;
+      validate_non_negative_index("log_cprob", "N", lcm_sym128__);
+      Eigen::Matrix<local_scalar_t__, -1, 1> log_cprob;
+      log_cprob = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym128__);
+      stan::math::fill(log_cprob, DUMMY_VAR__);
+      
+      local_scalar_t__ log_residual_prob;
+      log_residual_prob = DUMMY_VAR__;
+      
+      current_statement__ = 115;
+      if (logical_gte(lcm_sym128__, 1)) {
+        current_statement__ = 43;
+        assign(log_cprob, cons_list(index_uni(1), nil_index_list()),
+          (stan::math::log(
+             rvalue(gamma, cons_list(index_uni(1), nil_index_list()),
+               "gamma")) + 0), "assigning variable log_cprob");
+        current_statement__ = 42;
+        log_residual_prob = (0 +
+                              log1m(
+                                rvalue(gamma,
+                                  cons_list(index_uni(1), nil_index_list()),
+                                  "gamma")));
+        for (int n = 2; n <= lcm_sym128__; ++n) {
+          current_statement__ = 43;
+          assign(log_cprob, cons_list(index_uni(n), nil_index_list()),
+            (stan::math::log(
+               rvalue(gamma, cons_list(index_uni(n), nil_index_list()),
+                 "gamma")) + log_residual_prob),
+            "assigning variable log_cprob");
+          current_statement__ = 42;
+          log_residual_prob = (log_residual_prob +
+                                log1m(
+                                  rvalue(gamma,
+                                    cons_list(index_uni(n), nil_index_list()),
+                                    "gamma")));}
+      } 
+      current_statement__ = 116;
+      return stan::math::exp(log_cprob);
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct seq_cprob_functor__ {
+template <typename T0__>
+Eigen::Matrix<stan::promote_args_t<T0__>, -1, 1>
+operator()(const Eigen::Matrix<T0__, -1, 1>& gamma, std::ostream* pstream__)  const 
+{
+return seq_cprob(gamma, pstream__);
+}
+};
+
+class inlining_fail2_model : public model_base_crtp<inlining_fail2_model> {
+
+ private:
+  int lcm_sym323__;
+  int lcm_sym322__;
+  int lcm_sym321__;
+  int lcm_sym320__;
+  int lcm_sym319__;
+  int lcm_sym318__;
+  int lcm_sym317__;
+  int lcm_sym316__;
+  int lcm_sym315__;
+  int lcm_sym314__;
+  int lcm_sym313__;
+  int lcm_sym312__;
+  int lcm_sym311__;
+  int lcm_sym310__;
+  int lcm_sym309__;
+  int lcm_sym308__;
+  int lcm_sym307__;
+  int lcm_sym306__;
+  int lcm_sym305__;
+  int lcm_sym304__;
+  int lcm_sym303__;
+  int lcm_sym302__;
+  int lcm_sym301__;
+  int pos__;
+  int M;
+  int n_occasions;
+  std::vector<std::vector<int>> y;
+  std::vector<int> first;
+  std::vector<int> last;
+ 
+ public:
+  ~inlining_fail2_model() { }
+  
+  std::string model_name() const { return "inlining_fail2_model"; }
+  
+  inlining_fail2_model(stan::io::var_context& context__,
+                       unsigned int random_seed__ = 0,
+                       std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "inlining_fail2_model_namespace::inlining_fail2_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","M","int",
+          context__.to_vec());
+      M = std::numeric_limits<int>::min();
+      
+      current_statement__ = 92;
+      M = context__.vals_i("M")[(1 - 1)];
+      context__.validate_dims("data initialization","n_occasions","int",
+          context__.to_vec());
+      n_occasions = std::numeric_limits<int>::min();
+      
+      current_statement__ = 93;
+      n_occasions = context__.vals_i("n_occasions")[(1 - 1)];
+      current_statement__ = 94;
+      validate_non_negative_index("y", "M", M);
+      current_statement__ = 94;
+      validate_non_negative_index("y", "n_occasions", n_occasions);
+      context__.validate_dims("data initialization","y","int",
+          context__.to_vec(M, n_occasions));
+      y = std::vector<std::vector<int>>(M, std::vector<int>(n_occasions, std::numeric_limits<int>::min()));
+      
+      {
+        std::vector<int> y_flat__;
+        current_statement__ = 94;
+        assign(y_flat__, nil_index_list(), context__.vals_i("y"),
+          "assigning variable y_flat__");
+        current_statement__ = 94;
+        pos__ = 1;
+        lcm_sym302__ = logical_gte(n_occasions, 1);
+        if (lcm_sym302__) {
+          {
+            lcm_sym301__ = logical_gte(M, 1);
+            if (lcm_sym301__) {
+              current_statement__ = 94;
+              assign(y,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(1), nil_index_list())),
+                rvalue(y_flat__, cons_list(index_uni(1), nil_index_list()),
+                  "y_flat__"), "assigning variable y");
+              current_statement__ = 94;
+              pos__ = 2;
+              for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+                current_statement__ = 94;
+                assign(y,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(1), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 94;
+                pos__ = (pos__ + 1);}
+            } 
+            for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+              current_statement__ = 94;
+              if (lcm_sym301__) {
+                current_statement__ = 94;
+                assign(y,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 94;
+                pos__ = (pos__ + 1);
+                for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+                  current_statement__ = 94;
+                  assign(y,
+                    cons_list(index_uni(sym2__),
+                      cons_list(index_uni(sym1__), nil_index_list())),
+                    y_flat__[(pos__ - 1)], "assigning variable y");
+                  current_statement__ = 94;
+                  pos__ = (pos__ + 1);}
+              } }
+          }
+        } else {
+          lcm_sym301__ = logical_gte(M, 1);
+        }
+      }
+      current_statement__ = 95;
+      validate_non_negative_index("first", "M", M);
+      first = std::vector<int>(M, std::numeric_limits<int>::min());
+      
+      current_statement__ = 96;
+      validate_non_negative_index("last", "M", M);
+      last = std::vector<int>(M, std::numeric_limits<int>::min());
+      
+      current_statement__ = 98;
+      if (lcm_sym301__) {
+        int inline_sym41__;
+        int inline_sym43__;
+        inline_sym43__ = std::numeric_limits<int>::min();
+        
+        inline_sym43__ = 0;
+        for (int inline_sym44__ = 1; inline_sym44__ <= 1; ++inline_sym44__) {
+          lcm_sym309__ = size(
+                           rvalue(y,
+                             cons_list(index_uni(1), nil_index_list()), "y"));
+          for (int inline_sym42__ = 1; inline_sym42__ <= lcm_sym309__;
+               ++inline_sym42__) {
+            current_statement__ = 51;
+            if (rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")[
+                (inline_sym42__ - 1)]) {
+              inline_sym43__ = 1;
+              inline_sym41__ = inline_sym42__;
+              break;
+            } }
+          if (inline_sym43__) {
+            break;
+          } 
+          inline_sym43__ = 1;
+          inline_sym41__ = 0;
+          break;}
+        assign(first, cons_list(index_uni(1), nil_index_list()),
+          inline_sym41__, "assigning variable first");
+        for (int i = 2; i <= M; ++i) {
+          int inline_sym41__;
+          int inline_sym43__;
+          inline_sym43__ = std::numeric_limits<int>::min();
+          
+          inline_sym43__ = 0;
+          for (int inline_sym44__ = 1; inline_sym44__ <= 1; ++inline_sym44__) {
+            lcm_sym308__ = size(
+                             rvalue(y,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "y"));
+            for (int inline_sym42__ = 1; inline_sym42__ <= lcm_sym308__;
+                 ++inline_sym42__) {
+              current_statement__ = 51;
+              if (rvalue(y, cons_list(index_uni(i), nil_index_list()), "y")[
+                  (inline_sym42__ - 1)]) {
+                inline_sym43__ = 1;
+                inline_sym41__ = inline_sym42__;
+                break;
+              } }
+            if (inline_sym43__) {
+              break;
+            } 
+            inline_sym43__ = 1;
+            inline_sym41__ = 0;
+            break;}
+          assign(first, cons_list(index_uni(i), nil_index_list()),
+            inline_sym41__, "assigning variable first");}
+      } 
+      current_statement__ = 105;
+      if (lcm_sym301__) {
+        int inline_sym45__;
+        int inline_sym48__;
+        inline_sym48__ = std::numeric_limits<int>::min();
+        
+        inline_sym48__ = 0;
+        for (int inline_sym49__ = 1; inline_sym49__ <= 1; ++inline_sym49__) {
+          lcm_sym309__ = size(
+                           rvalue(y,
+                             cons_list(index_uni(1), nil_index_list()), "y"));
+          lcm_sym306__ = (lcm_sym309__ - 1);
+          for (int inline_sym47__ = 0; inline_sym47__ <= lcm_sym306__;
+               ++inline_sym47__) {
+            int inline_sym46__;
+            inline_sym46__ = std::numeric_limits<int>::min();
+            
+            lcm_sym305__ = (lcm_sym309__ - inline_sym47__);
+            inline_sym46__ = lcm_sym305__;
+            current_statement__ = 101;
+            if (rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")[
+                (lcm_sym305__ - 1)]) {
+              inline_sym48__ = 1;
+              inline_sym45__ = lcm_sym305__;
+              break;
+            } }
+          if (inline_sym48__) {
+            break;
+          } 
+          inline_sym48__ = 1;
+          inline_sym45__ = 0;
+          break;}
+        assign(last, cons_list(index_uni(1), nil_index_list()),
+          inline_sym45__, "assigning variable last");
+        for (int i = 2; i <= M; ++i) {
+          int inline_sym45__;
+          int inline_sym48__;
+          inline_sym48__ = std::numeric_limits<int>::min();
+          
+          inline_sym48__ = 0;
+          for (int inline_sym49__ = 1; inline_sym49__ <= 1; ++inline_sym49__) {
+            lcm_sym308__ = size(
+                             rvalue(y,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "y"));
+            lcm_sym304__ = (lcm_sym308__ - 1);
+            for (int inline_sym47__ = 0; inline_sym47__ <= lcm_sym304__;
+                 ++inline_sym47__) {
+              int inline_sym46__;
+              inline_sym46__ = std::numeric_limits<int>::min();
+              
+              lcm_sym303__ = (lcm_sym308__ - inline_sym47__);
+              inline_sym46__ = lcm_sym303__;
+              current_statement__ = 101;
+              if (rvalue(y, cons_list(index_uni(i), nil_index_list()), "y")[
+                  (lcm_sym303__ - 1)]) {
+                inline_sym48__ = 1;
+                inline_sym45__ = lcm_sym303__;
+                break;
+              } }
+            if (inline_sym48__) {
+              break;
+            } 
+            inline_sym48__ = 1;
+            inline_sym45__ = 0;
+            break;}
+          assign(last, cons_list(index_uni(i), nil_index_list()),
+            inline_sym45__, "assigning variable last");}
+      } 
+      current_statement__ = 92;
+      current_statement__ = 92;
+      check_greater_or_equal(function__, "M", M, 0);
+      current_statement__ = 93;
+      current_statement__ = 93;
+      check_greater_or_equal(function__, "n_occasions", n_occasions, 0);
+      current_statement__ = 94;
+      if (lcm_sym301__) {
+        current_statement__ = 94;
+        if (lcm_sym302__) {
+          current_statement__ = 94;
+          current_statement__ = 94;
+          check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                 rvalue(y,
+                                   cons_list(index_uni(1),
+                                     cons_list(index_uni(1),
+                                       nil_index_list())), "y"), 0);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 94;
+            current_statement__ = 94;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(1),
+                                       cons_list(index_uni(sym2__),
+                                         nil_index_list())), "y"), 0);}
+        } 
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 94;
+          if (lcm_sym302__) {
+            current_statement__ = 94;
+            current_statement__ = 94;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(sym1__),
+                                       cons_list(index_uni(1),
+                                         nil_index_list())), "y"), 0);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 94;
+              current_statement__ = 94;
+              check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                     y[(sym1__ - 1)][(sym2__ - 1)], 0);}
+          } }
+      } 
+      current_statement__ = 94;
+      if (lcm_sym301__) {
+        current_statement__ = 94;
+        if (lcm_sym302__) {
+          current_statement__ = 94;
+          current_statement__ = 94;
+          check_less_or_equal(function__, "y[sym1__, sym2__]",
+                              rvalue(y,
+                                cons_list(index_uni(1),
+                                  cons_list(index_uni(1), nil_index_list())),
+                                "y"), 1);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 94;
+            current_statement__ = 94;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(1),
+                                    cons_list(index_uni(sym2__),
+                                      nil_index_list())), "y"), 1);}
+        } 
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 94;
+          if (lcm_sym302__) {
+            current_statement__ = 94;
+            current_statement__ = 94;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(sym1__),
+                                    cons_list(index_uni(1), nil_index_list())),
+                                  "y"), 1);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 94;
+              current_statement__ = 94;
+              check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                  y[(sym1__ - 1)][(sym2__ - 1)], 1);}
+          } }
+      } 
+      current_statement__ = 95;
+      if (lcm_sym301__) {
+        current_statement__ = 95;
+        current_statement__ = 95;
+        check_greater_or_equal(function__, "first[sym1__]",
+                               rvalue(first,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "first"), 0);
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 95;
+          current_statement__ = 95;
+          check_greater_or_equal(function__, "first[sym1__]",
+                                 first[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 95;
+      if (lcm_sym301__) {
+        current_statement__ = 95;
+        current_statement__ = 95;
+        check_less_or_equal(function__, "first[sym1__]",
+                            rvalue(first,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "first"), n_occasions);
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 95;
+          current_statement__ = 95;
+          check_less_or_equal(function__, "first[sym1__]",
+                              first[(sym1__ - 1)], n_occasions);}
+      } 
+      current_statement__ = 96;
+      if (lcm_sym301__) {
+        current_statement__ = 96;
+        current_statement__ = 96;
+        check_greater_or_equal(function__, "last[sym1__]",
+                               rvalue(last,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "last"), 0);
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 96;
+          current_statement__ = 96;
+          check_greater_or_equal(function__, "last[sym1__]",
+                                 last[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 96;
+      if (lcm_sym301__) {
+        current_statement__ = 96;
+        current_statement__ = 96;
+        check_less_or_equal(function__, "last[sym1__]",
+                            rvalue(last,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "last"), n_occasions);
+        for (int sym1__ = 2; sym1__ <= M; ++sym1__) {
+          current_statement__ = 96;
+          current_statement__ = 96;
+          check_less_or_equal(function__, "last[sym1__]", last[(sym1__ - 1)],
+                              n_occasions);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      current_statement__ = 3;
+      validate_non_negative_index("gamma", "n_occasions", n_occasions);
+      num_params_r__ += n_occasions;
+      current_statement__ = 4;
+      validate_non_negative_index("epsilon", "(n_occasions - 1)",
+                                  (n_occasions - 1));
+      num_params_r__ += (n_occasions - 1);
+      num_params_r__ += 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "inlining_fail2_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      int lcm_sym300__;
+      int lcm_sym299__;
+      int lcm_sym298__;
+      int lcm_sym297__;
+      local_scalar_t__ lcm_sym293__;
+      double lcm_sym291__;
+      int lcm_sym296__;
+      int lcm_sym295__;
+      int lcm_sym289__;
+      Eigen::Matrix<local_scalar_t__, -1, -1> lcm_sym288__;
+      double lcm_sym287__;
+      double lcm_sym286__;
+      local_scalar_t__ lcm_sym285__;
+      local_scalar_t__ lcm_sym284__;
+      double lcm_sym283__;
+      double lcm_sym282__;
+      int lcm_sym281__;
+      double lcm_sym280__;
+      double lcm_sym279__;
+      double lcm_sym278__;
+      double lcm_sym277__;
+      double lcm_sym276__;
+      double lcm_sym275__;
+      double lcm_sym274__;
+      double lcm_sym273__;
+      double lcm_sym272__;
+      double lcm_sym271__;
+      double lcm_sym270__;
+      double lcm_sym269__;
+      double lcm_sym268__;
+      int lcm_sym267__;
+      int lcm_sym266__;
+      int lcm_sym265__;
+      double lcm_sym264__;
+      double lcm_sym263__;
+      double lcm_sym262__;
+      double lcm_sym261__;
+      double lcm_sym260__;
+      double lcm_sym259__;
+      double lcm_sym258__;
+      double lcm_sym257__;
+      double lcm_sym256__;
+      double lcm_sym255__;
+      double lcm_sym254__;
+      double lcm_sym253__;
+      double lcm_sym252__;
+      double lcm_sym251__;
+      int lcm_sym250__;
+      int lcm_sym249__;
+      int lcm_sym248__;
+      int lcm_sym247__;
+      int lcm_sym246__;
+      int lcm_sym245__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym244__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym243__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym242__;
+      int lcm_sym294__;
+      int lcm_sym240__;
+      int lcm_sym239__;
+      int lcm_sym238__;
+      int lcm_sym237__;
+      int lcm_sym236__;
+      int lcm_sym235__;
+      int lcm_sym234__;
+      int lcm_sym233__;
+      int lcm_sym232__;
+      int lcm_sym231__;
+      int lcm_sym230__;
+      int lcm_sym229__;
+      local_scalar_t__ mean_phi;
+      mean_phi = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      mean_phi = in__.scalar();
+      current_statement__ = 1;
+      if (jacobian__) {
+        current_statement__ = 1;
+        mean_phi = stan::math::lub_constrain(mean_phi, 0, 1, lp__);
+      } else {
+        current_statement__ = 1;
+        mean_phi = stan::math::lub_constrain(mean_phi, 0, 1);
+      }
+      local_scalar_t__ mean_p;
+      mean_p = DUMMY_VAR__;
+      
+      current_statement__ = 2;
+      mean_p = in__.scalar();
+      current_statement__ = 2;
+      if (jacobian__) {
+        current_statement__ = 2;
+        mean_p = stan::math::lub_constrain(mean_p, 0, 1, lp__);
+      } else {
+        current_statement__ = 2;
+        mean_p = stan::math::lub_constrain(mean_p, 0, 1);
+      }
+      current_statement__ = 3;
+      validate_non_negative_index("gamma", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, 1> gamma;
+      gamma = Eigen::Matrix<local_scalar_t__, -1, 1>(n_occasions);
+      stan::math::fill(gamma, DUMMY_VAR__);
+      
+      current_statement__ = 3;
+      gamma = in__.vector(n_occasions);
+      current_statement__ = 3;
+      if (logical_gte(n_occasions, 1)) {
+        current_statement__ = 3;
+        if (jacobian__) {
+          current_statement__ = 3;
+          assign(gamma, cons_list(index_uni(1), nil_index_list()),
+            stan::math::lub_constrain(
+              rvalue(gamma, cons_list(index_uni(1), nil_index_list()),
+                "gamma"), 0, 1, lp__), "assigning variable gamma");
+        } else {
+          current_statement__ = 3;
+          assign(gamma, cons_list(index_uni(1), nil_index_list()),
+            stan::math::lub_constrain(
+              rvalue(gamma, cons_list(index_uni(1), nil_index_list()),
+                "gamma"), 0, 1), "assigning variable gamma");
+        }
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          current_statement__ = 3;
+          if (jacobian__) {
+            current_statement__ = 3;
+            assign(gamma, cons_list(index_uni(sym1__), nil_index_list()),
+              stan::math::lub_constrain(gamma[(sym1__ - 1)], 0, 1, lp__),
+              "assigning variable gamma");
+          } else {
+            current_statement__ = 3;
+            assign(gamma, cons_list(index_uni(sym1__), nil_index_list()),
+              stan::math::lub_constrain(gamma[(sym1__ - 1)], 0, 1),
+              "assigning variable gamma");
+          }}
+      } 
+      lcm_sym294__ = (n_occasions - 1);
+      validate_non_negative_index("epsilon", "(n_occasions - 1)",
+                                  lcm_sym294__);
+      Eigen::Matrix<local_scalar_t__, -1, 1> epsilon;
+      epsilon = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym294__);
+      stan::math::fill(epsilon, DUMMY_VAR__);
+      
+      current_statement__ = 4;
+      epsilon = in__.vector(lcm_sym294__);
+      local_scalar_t__ sigma;
+      sigma = DUMMY_VAR__;
+      
+      current_statement__ = 5;
+      sigma = in__.scalar();
+      current_statement__ = 5;
+      if (jacobian__) {
+        current_statement__ = 5;
+        sigma = stan::math::lub_constrain(sigma, 0, 5, lp__);
+      } else {
+        current_statement__ = 5;
+        sigma = stan::math::lub_constrain(sigma, 0, 5);
+      }
+      current_statement__ = 6;
+      validate_non_negative_index("phi", "M", M);
+      current_statement__ = 6;
+      validate_non_negative_index("phi", "(n_occasions - 1)", lcm_sym294__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> phi;
+      phi = Eigen::Matrix<local_scalar_t__, -1, -1>(M, lcm_sym294__);
+      stan::math::fill(phi, DUMMY_VAR__);
+      
+      current_statement__ = 7;
+      validate_non_negative_index("p", "M", M);
+      current_statement__ = 7;
+      validate_non_negative_index("p", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> p;
+      p = Eigen::Matrix<local_scalar_t__, -1, -1>(M, n_occasions);
+      stan::math::fill(p, DUMMY_VAR__);
+      
+      current_statement__ = 8;
+      validate_non_negative_index("chi", "M", M);
+      current_statement__ = 8;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(M, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      current_statement__ = 11;
+      if (logical_gte(lcm_sym294__, 1)) {
+        lcm_sym231__ = logical_gte(M, 1);
+        if (lcm_sym231__) {
+          lcm_sym285__ = inv_logit(
+                           (logit(mean_phi) +
+                             rvalue(epsilon,
+                               cons_list(index_uni(1), nil_index_list()),
+                               "epsilon")));
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), lcm_sym285__,
+            "assigning variable phi");
+          for (int i = 2; i <= M; ++i) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), lcm_sym285__,
+              "assigning variable phi");}
+        } 
+        for (int t = 2; t <= lcm_sym294__; ++t) {
+          current_statement__ = 10;
+          if (lcm_sym231__) {
+            lcm_sym284__ = inv_logit(
+                             (logit(mean_phi) +
+                               rvalue(epsilon,
+                                 cons_list(index_uni(t), nil_index_list()),
+                                 "epsilon")));
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), lcm_sym284__,
+              "assigning variable phi");
+            for (int i = 2; i <= M; ++i) {
+              current_statement__ = 9;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), lcm_sym284__,
+                "assigning variable phi");}
+          } }
+      } 
+      assign(lcm_sym288__, nil_index_list(),
+        rep_matrix(mean_p, M, n_occasions), "assigning variable lcm_sym288__");
+      assign(p, nil_index_list(), lcm_sym288__, "assigning variable p");
+      Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym22__;
+      int inline_sym30__;
+      inline_sym30__ = std::numeric_limits<int>::min();
+      
+      inline_sym30__ = 0;
+      for (int inline_sym31__ = 1; inline_sym31__ <= 1; ++inline_sym31__) {
+        int inline_sym23__;
+        inline_sym23__ = std::numeric_limits<int>::min();
+        
+        lcm_sym289__ = rows(lcm_sym288__);
+        int inline_sym24__;
+        inline_sym24__ = std::numeric_limits<int>::min();
+        
+        lcm_sym281__ = cols(lcm_sym288__);
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "n_ind", lcm_sym289__);
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "n_occasions", lcm_sym281__);
+        Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym25__;
+        inline_sym25__ = Eigen::Matrix<local_scalar_t__, -1, -1>(lcm_sym289__, lcm_sym281__);
+        stan::math::fill(inline_sym25__, DUMMY_VAR__);
+        
+        for (int inline_sym29__ = 1; inline_sym29__ <= lcm_sym289__;
+             ++inline_sym29__) {
+          current_statement__ = 15;
+          assign(inline_sym25__,
+            cons_list(index_uni(inline_sym29__),
+              cons_list(index_uni(lcm_sym281__), nil_index_list())), 1.0,
+            "assigning variable inline_sym25__");
+          lcm_sym246__ = (lcm_sym281__ - 1);
+          if (logical_gte(lcm_sym246__, 1)) {
+            int inline_sym26__;
+            inline_sym26__ = std::numeric_limits<int>::min();
+            
+            int inline_sym27__;
+            inline_sym27__ = std::numeric_limits<int>::min();
+            
+            lcm_sym250__ = (lcm_sym246__ + 1);
+            current_statement__ = 18;
+            assign(inline_sym25__,
+              cons_list(index_uni(inline_sym29__),
+                cons_list(index_uni(lcm_sym246__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(inline_sym29__),
+                     cons_list(index_uni(lcm_sym246__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(lcm_sym288__,
+                      cons_list(index_uni(inline_sym29__),
+                        cons_list(index_uni(lcm_sym250__), nil_index_list())),
+                      "lcm_sym288__"))),
+                rvalue(inline_sym25__,
+                  cons_list(index_uni(inline_sym29__),
+                    cons_list(index_uni(lcm_sym250__), nil_index_list())),
+                  "inline_sym25__"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(inline_sym29__),
+                      cons_list(index_uni(lcm_sym246__), nil_index_list())),
+                    "phi"))), "assigning variable inline_sym25__");
+            for (int inline_sym28__ = 2; inline_sym28__ <= lcm_sym246__;
+                 ++inline_sym28__) {
+              int inline_sym26__;
+              inline_sym26__ = std::numeric_limits<int>::min();
+              
+              lcm_sym245__ = (lcm_sym281__ - inline_sym28__);
+              int inline_sym27__;
+              inline_sym27__ = std::numeric_limits<int>::min();
+              
+              lcm_sym249__ = (lcm_sym245__ + 1);
+              current_statement__ = 18;
+              assign(inline_sym25__,
+                cons_list(index_uni(inline_sym29__),
+                  cons_list(index_uni(lcm_sym245__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(inline_sym29__),
+                       cons_list(index_uni(lcm_sym245__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(lcm_sym288__,
+                        cons_list(index_uni(inline_sym29__),
+                          cons_list(index_uni(lcm_sym249__),
+                            nil_index_list())), "lcm_sym288__"))),
+                  rvalue(inline_sym25__,
+                    cons_list(index_uni(inline_sym29__),
+                      cons_list(index_uni(lcm_sym249__), nil_index_list())),
+                    "inline_sym25__"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(inline_sym29__),
+                        cons_list(index_uni(lcm_sym245__), nil_index_list())),
+                      "phi"))), "assigning variable inline_sym25__");}
+          } 
+          if (inline_sym30__) {
+            break;
+          } }
+        if (inline_sym30__) {
+          break;
+        } 
+        inline_sym30__ = 1;
+        assign(inline_sym22__, nil_index_list(), inline_sym25__,
+          "assigning variable inline_sym22__");
+        break;}
+      assign(chi, nil_index_list(), inline_sym22__, "assigning variable chi");
+      current_statement__ = 6;
+      current_statement__ = 6;
+      check_greater_or_equal(function__, "phi", phi, 0);
+      current_statement__ = 6;
+      current_statement__ = 6;
+      check_less_or_equal(function__, "phi", phi, 1);
+      current_statement__ = 7;
+      current_statement__ = 7;
+      check_greater_or_equal(function__, "p", lcm_sym288__, 0);
+      current_statement__ = 7;
+      current_statement__ = 7;
+      check_less_or_equal(function__, "p", lcm_sym288__, 1);
+      current_statement__ = 8;
+      current_statement__ = 8;
+      check_greater_or_equal(function__, "chi", inline_sym22__, 0);
+      current_statement__ = 8;
+      current_statement__ = 8;
+      check_less_or_equal(function__, "chi", inline_sym22__, 1);
+      {
+        current_statement__ = 67;
+        lp_accum__.add(normal_log<propto__>(epsilon, 0, sigma));
+        int inline_sym39__;
+        inline_sym39__ = std::numeric_limits<int>::min();
+        
+        {
+          int inline_sym32__;
+          inline_sym32__ = std::numeric_limits<int>::min();
+          
+          lcm_sym299__ = rvalue(dims(y),
+                           cons_list(index_uni(1), nil_index_list()),
+                           "dims(y)");
+          int inline_sym33__;
+          inline_sym33__ = std::numeric_limits<int>::min();
+          
+          lcm_sym300__ = rvalue(dims(y),
+                           cons_list(index_uni(2), nil_index_list()),
+                           "dims(y)");
+          current_statement__ = 70;
+          validate_non_negative_index("qgamma", "n_occasions", lcm_sym300__);
+          Eigen::Matrix<double, -1, 1> inline_sym34__;
+          inline_sym34__ = Eigen::Matrix<double, -1, 1>(lcm_sym300__);
+          stan::math::fill(inline_sym34__, std::numeric_limits<double>::quiet_NaN());
+          
+          assign(lcm_sym242__, nil_index_list(), subtract(1.0, gamma),
+            "assigning variable lcm_sym242__");
+          lcm_sym239__ = logical_gte(lcm_sym299__, 1);
+          if (lcm_sym239__) {
+            current_statement__ = 71;
+            validate_non_negative_index("qp", "n_occasions", lcm_sym300__);
+            Eigen::Matrix<double, -1, 1> inline_sym35__;
+            inline_sym35__ = Eigen::Matrix<double, -1, 1>(lcm_sym300__);
+            stan::math::fill(inline_sym35__, std::numeric_limits<double>::quiet_NaN());
+            
+            assign(lcm_sym244__, nil_index_list(),
+              subtract(1.0,
+                transpose(
+                  rvalue(lcm_sym288__,
+                    cons_list(index_uni(1), nil_index_list()),
+                    "lcm_sym288__"))), "assigning variable lcm_sym244__");
+            lcm_sym296__ = rvalue(first,
+                             cons_list(index_uni(1), nil_index_list()),
+                             "first");
+            if (lcm_sym296__) {
+              current_statement__ = 83;
+              if (logical_eq(lcm_sym296__, 1)) {
+                lcm_sym293__ = rvalue(gamma,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "gamma");
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    (lcm_sym293__ *
+                      rvalue(lcm_sym288__,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(1), nil_index_list())),
+                        "lcm_sym288__"))));
+              } else {
+                current_statement__ = 77;
+                validate_non_negative_index("lp",
+                                            "rvalue(first, cons_list(index_uni(i), nil_index_list()), \"first\")",
+                                            lcm_sym296__);
+                Eigen::Matrix<local_scalar_t__, -1, 1> inline_sym36__;
+                inline_sym36__ = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym296__);
+                stan::math::fill(inline_sym36__, DUMMY_VAR__);
+                
+                lcm_sym293__ = rvalue(gamma,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "gamma");
+                lcm_sym248__ = (lcm_sym296__ - 1);
+                assign(inline_sym36__,
+                  cons_list(index_uni(1), nil_index_list()),
+                  (((bernoulli_lpmf<false>(1, lcm_sym293__) +
+                      bernoulli_lpmf<false>(1,
+                        prod(
+                          rvalue(lcm_sym244__,
+                            cons_list(index_min_max(1, lcm_sym248__),
+                              nil_index_list()), "lcm_sym244__")))) +
+                     bernoulli_lpmf<false>(1,
+                       prod(
+                         rvalue(phi,
+                           cons_list(index_uni(1),
+                             cons_list(index_min_max(1, lcm_sym248__),
+                               nil_index_list())), "phi")))) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(lcm_sym288__,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(lcm_sym296__),
+                            nil_index_list())), "lcm_sym288__"))),
+                  "assigning variable inline_sym36__");
+                if (logical_gte(lcm_sym248__, 2)) {
+                  current_statement__ = 78;
+                  assign(inline_sym36__,
+                    cons_list(index_uni(2), nil_index_list()),
+                    ((((bernoulli_lpmf<false>(1,
+                          prod(
+                            rvalue(lcm_sym242__,
+                              cons_list(index_min_max(1, 1),
+                                nil_index_list()), "lcm_sym242__"))) +
+                         bernoulli_lpmf<false>(1,
+                           rvalue(gamma,
+                             cons_list(index_uni(2), nil_index_list()),
+                             "gamma"))) +
+                        bernoulli_lpmf<false>(1,
+                          prod(
+                            rvalue(lcm_sym244__,
+                              cons_list(index_min_max(2, lcm_sym248__),
+                                nil_index_list()), "lcm_sym244__")))) +
+                       bernoulli_lpmf<false>(1,
+                         prod(
+                           rvalue(phi,
+                             cons_list(index_uni(1),
+                               cons_list(index_min_max(2, lcm_sym248__),
+                                 nil_index_list())), "phi")))) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(lcm_sym288__,
+                          cons_list(index_uni(1),
+                            cons_list(index_uni(lcm_sym296__),
+                              nil_index_list())), "lcm_sym288__"))),
+                    "assigning variable inline_sym36__");
+                  for (int inline_sym37__ = 3;
+                       inline_sym37__ <= lcm_sym248__; ++inline_sym37__) {
+                    current_statement__ = 78;
+                    assign(inline_sym36__,
+                      cons_list(index_uni(inline_sym37__), nil_index_list()),
+                      ((((bernoulli_lpmf<false>(1,
+                            prod(
+                              rvalue(lcm_sym242__,
+                                cons_list(
+                                  index_min_max(1, (inline_sym37__ - 1)),
+                                  nil_index_list()), "lcm_sym242__"))) +
+                           bernoulli_lpmf<false>(1,
+                             gamma[(inline_sym37__ - 1)])) +
+                          bernoulli_lpmf<false>(1,
+                            prod(
+                              rvalue(lcm_sym244__,
+                                cons_list(
+                                  index_min_max(inline_sym37__, lcm_sym248__),
+                                  nil_index_list()), "lcm_sym244__")))) +
+                         bernoulli_lpmf<false>(1,
+                           prod(
+                             rvalue(phi,
+                               cons_list(index_uni(1),
+                                 cons_list(
+                                   index_min_max(inline_sym37__, lcm_sym248__),
+                                   nil_index_list())), "phi")))) +
+                        bernoulli_lpmf<false>(1,
+                          rvalue(lcm_sym288__,
+                            cons_list(index_uni(1),
+                              cons_list(index_uni(lcm_sym296__),
+                                nil_index_list())), "lcm_sym288__"))),
+                      "assigning variable inline_sym36__");}
+                } 
+                current_statement__ = 79;
+                assign(inline_sym36__,
+                  cons_list(index_uni(lcm_sym296__), nil_index_list()),
+                  ((bernoulli_lpmf<false>(1,
+                      prod(
+                        rvalue(lcm_sym242__,
+                          cons_list(index_min_max(1, lcm_sym248__),
+                            nil_index_list()), "lcm_sym242__"))) +
+                     bernoulli_lpmf<false>(1, gamma[(lcm_sym296__ - 1)])) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(lcm_sym288__,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(lcm_sym296__),
+                            nil_index_list())), "lcm_sym288__"))),
+                  "assigning variable inline_sym36__");
+                current_statement__ = 80;
+                lp_accum__.add(log_sum_exp(inline_sym36__));
+              }
+              lcm_sym298__ = rvalue(last,
+                               cons_list(index_uni(1), nil_index_list()),
+                               "last");
+              if (logical_gte(lcm_sym298__, (lcm_sym296__ + 1))) {
+                current_statement__ = 84;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(phi,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(((lcm_sym296__ + 1) - 1)),
+                          nil_index_list())), "phi")));
+                lcm_sym266__ = ((lcm_sym296__ + 1) + 1);
+                lp_accum__.add(
+                  bernoulli_log<propto__>(
+                    rvalue(y,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((lcm_sym296__ + 1)),
+                          nil_index_list())), "y"),
+                    rvalue(lcm_sym288__,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((lcm_sym296__ + 1)),
+                          nil_index_list())), "lcm_sym288__")));
+                for (int inline_sym37__ = lcm_sym266__;
+                     inline_sym37__ <= lcm_sym298__; ++inline_sym37__) {
+                  current_statement__ = 84;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(1,
+                      rvalue(phi,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni((inline_sym37__ - 1)),
+                            nil_index_list())), "phi")));
+                  current_statement__ = 85;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(
+                      rvalue(y,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(inline_sym37__),
+                            nil_index_list())), "y"),
+                      rvalue(lcm_sym288__,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(inline_sym37__),
+                            nil_index_list())), "lcm_sym288__")));}
+              } 
+              current_statement__ = 87;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(inline_sym22__,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym298__), nil_index_list())),
+                    "inline_sym22__")));
+            } else {
+              lcm_sym267__ = (lcm_sym300__ + 1);
+              validate_non_negative_index("lp", "(n_occasions + 1)",
+                                          lcm_sym267__);
+              Eigen::Matrix<local_scalar_t__, -1, 1> inline_sym36__;
+              inline_sym36__ = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym267__);
+              stan::math::fill(inline_sym36__, DUMMY_VAR__);
+              
+              lcm_sym293__ = rvalue(gamma,
+                               cons_list(index_uni(1), nil_index_list()),
+                               "gamma");
+              assign(inline_sym36__,
+                cons_list(index_uni(1), nil_index_list()),
+                ((bernoulli_lpmf<false>(1, lcm_sym293__) +
+                   bernoulli_lpmf<false>(0,
+                     rvalue(lcm_sym288__,
+                       cons_list(index_uni(1),
+                         cons_list(index_uni(1), nil_index_list())),
+                       "lcm_sym288__"))) +
+                  bernoulli_lpmf<false>(1,
+                    rvalue(inline_sym22__,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(1), nil_index_list())),
+                      "inline_sym22__"))),
+                "assigning variable inline_sym36__");
+              if (logical_gte(lcm_sym300__, 2)) {
+                current_statement__ = 73;
+                assign(inline_sym36__,
+                  cons_list(index_uni(2), nil_index_list()),
+                  (((bernoulli_lpmf<false>(1,
+                       prod(
+                         rvalue(lcm_sym242__,
+                           cons_list(index_min_max(1, 1), nil_index_list()),
+                           "lcm_sym242__"))) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(gamma,
+                          cons_list(index_uni(2), nil_index_list()), "gamma")))
+                     +
+                     bernoulli_lpmf<false>(0,
+                       rvalue(lcm_sym288__,
+                         cons_list(index_uni(1),
+                           cons_list(index_uni(2), nil_index_list())),
+                         "lcm_sym288__"))) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(inline_sym22__,
+                        cons_list(index_uni(1),
+                          cons_list(index_uni(2), nil_index_list())),
+                        "inline_sym22__"))),
+                  "assigning variable inline_sym36__");
+                for (int inline_sym37__ = 3; inline_sym37__ <= lcm_sym300__;
+                     ++inline_sym37__) {
+                  current_statement__ = 73;
+                  assign(inline_sym36__,
+                    cons_list(index_uni(inline_sym37__), nil_index_list()),
+                    (((bernoulli_lpmf<false>(1,
+                         prod(
+                           rvalue(lcm_sym242__,
+                             cons_list(
+                               index_min_max(1, (inline_sym37__ - 1)),
+                               nil_index_list()), "lcm_sym242__"))) +
+                        bernoulli_lpmf<false>(1, gamma[(inline_sym37__ - 1)]))
+                       +
+                       bernoulli_lpmf<false>(0,
+                         rvalue(lcm_sym288__,
+                           cons_list(index_uni(1),
+                             cons_list(index_uni(inline_sym37__),
+                               nil_index_list())), "lcm_sym288__"))) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(inline_sym22__,
+                          cons_list(index_uni(1),
+                            cons_list(index_uni(inline_sym37__),
+                              nil_index_list())), "inline_sym22__"))),
+                    "assigning variable inline_sym36__");}
+              } 
+              current_statement__ = 74;
+              assign(inline_sym36__,
+                cons_list(index_uni(lcm_sym267__), nil_index_list()),
+                bernoulli_lpmf<false>(1, prod(lcm_sym242__)),
+                "assigning variable inline_sym36__");
+              current_statement__ = 75;
+              lp_accum__.add(log_sum_exp(inline_sym36__));
+            }
+            for (int inline_sym38__ = 2; inline_sym38__ <= lcm_sym299__;
+                 ++inline_sym38__) {
+              current_statement__ = 71;
+              validate_non_negative_index("qp", "n_occasions", lcm_sym300__);
+              Eigen::Matrix<double, -1, 1> inline_sym35__;
+              inline_sym35__ = Eigen::Matrix<double, -1, 1>(lcm_sym300__);
+              stan::math::fill(inline_sym35__, std::numeric_limits<double>::quiet_NaN());
+              
+              assign(lcm_sym243__, nil_index_list(),
+                subtract(1.0,
+                  transpose(
+                    rvalue(lcm_sym288__,
+                      cons_list(index_uni(inline_sym38__), nil_index_list()),
+                      "lcm_sym288__"))), "assigning variable lcm_sym243__");
+              lcm_sym295__ = first[(inline_sym38__ - 1)];
+              if (lcm_sym295__) {
+                current_statement__ = 83;
+                if (logical_eq(lcm_sym295__, 1)) {
+                  current_statement__ = 90;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(1,
+                      (lcm_sym293__ *
+                        rvalue(lcm_sym288__,
+                          cons_list(index_uni(inline_sym38__),
+                            cons_list(index_uni(1), nil_index_list())),
+                          "lcm_sym288__"))));
+                } else {
+                  current_statement__ = 77;
+                  validate_non_negative_index("lp",
+                                              "rvalue(first, cons_list(index_uni(i), nil_index_list()), \"first\")",
+                                              lcm_sym295__);
+                  Eigen::Matrix<local_scalar_t__, -1, 1> inline_sym36__;
+                  inline_sym36__ = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym295__);
+                  stan::math::fill(inline_sym36__, DUMMY_VAR__);
+                  
+                  lcm_sym247__ = (lcm_sym295__ - 1);
+                  assign(inline_sym36__,
+                    cons_list(index_uni(1), nil_index_list()),
+                    (((bernoulli_lpmf<false>(1, lcm_sym293__) +
+                        bernoulli_lpmf<false>(1,
+                          prod(
+                            rvalue(lcm_sym243__,
+                              cons_list(index_min_max(1, lcm_sym247__),
+                                nil_index_list()), "lcm_sym243__")))) +
+                       bernoulli_lpmf<false>(1,
+                         prod(
+                           rvalue(phi,
+                             cons_list(index_uni(inline_sym38__),
+                               cons_list(index_min_max(1, lcm_sym247__),
+                                 nil_index_list())), "phi")))) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(lcm_sym288__,
+                          cons_list(index_uni(inline_sym38__),
+                            cons_list(index_uni(lcm_sym295__),
+                              nil_index_list())), "lcm_sym288__"))),
+                    "assigning variable inline_sym36__");
+                  if (logical_gte(lcm_sym247__, 2)) {
+                    current_statement__ = 78;
+                    assign(inline_sym36__,
+                      cons_list(index_uni(2), nil_index_list()),
+                      ((((bernoulli_lpmf<false>(1,
+                            prod(
+                              rvalue(lcm_sym242__,
+                                cons_list(index_min_max(1, 1),
+                                  nil_index_list()), "lcm_sym242__"))) +
+                           bernoulli_lpmf<false>(1,
+                             rvalue(gamma,
+                               cons_list(index_uni(2), nil_index_list()),
+                               "gamma"))) +
+                          bernoulli_lpmf<false>(1,
+                            prod(
+                              rvalue(lcm_sym243__,
+                                cons_list(index_min_max(2, lcm_sym247__),
+                                  nil_index_list()), "lcm_sym243__")))) +
+                         bernoulli_lpmf<false>(1,
+                           prod(
+                             rvalue(phi,
+                               cons_list(index_uni(inline_sym38__),
+                                 cons_list(index_min_max(2, lcm_sym247__),
+                                   nil_index_list())), "phi")))) +
+                        bernoulli_lpmf<false>(1,
+                          rvalue(lcm_sym288__,
+                            cons_list(index_uni(inline_sym38__),
+                              cons_list(index_uni(lcm_sym295__),
+                                nil_index_list())), "lcm_sym288__"))),
+                      "assigning variable inline_sym36__");
+                    for (int inline_sym37__ = 3;
+                         inline_sym37__ <= lcm_sym247__; ++inline_sym37__) {
+                      current_statement__ = 78;
+                      assign(inline_sym36__,
+                        cons_list(index_uni(inline_sym37__),
+                          nil_index_list()),
+                        ((((bernoulli_lpmf<false>(1,
+                              prod(
+                                rvalue(lcm_sym242__,
+                                  cons_list(
+                                    index_min_max(1, (inline_sym37__ - 1)),
+                                    nil_index_list()), "lcm_sym242__"))) +
+                             bernoulli_lpmf<false>(1,
+                               gamma[(inline_sym37__ - 1)])) +
+                            bernoulli_lpmf<false>(1,
+                              prod(
+                                rvalue(lcm_sym243__,
+                                  cons_list(
+                                    index_min_max(inline_sym37__, lcm_sym247__),
+                                    nil_index_list()), "lcm_sym243__")))) +
+                           bernoulli_lpmf<false>(1,
+                             prod(
+                               rvalue(phi,
+                                 cons_list(index_uni(inline_sym38__),
+                                   cons_list(
+                                     index_min_max(inline_sym37__, lcm_sym247__),
+                                     nil_index_list())), "phi")))) +
+                          bernoulli_lpmf<false>(1,
+                            rvalue(lcm_sym288__,
+                              cons_list(index_uni(inline_sym38__),
+                                cons_list(index_uni(lcm_sym295__),
+                                  nil_index_list())), "lcm_sym288__"))),
+                        "assigning variable inline_sym36__");}
+                  } 
+                  current_statement__ = 79;
+                  assign(inline_sym36__,
+                    cons_list(index_uni(lcm_sym295__), nil_index_list()),
+                    ((bernoulli_lpmf<false>(1,
+                        prod(
+                          rvalue(lcm_sym242__,
+                            cons_list(index_min_max(1, lcm_sym247__),
+                              nil_index_list()), "lcm_sym242__"))) +
+                       bernoulli_lpmf<false>(1, gamma[(lcm_sym295__ - 1)])) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(lcm_sym288__,
+                          cons_list(index_uni(inline_sym38__),
+                            cons_list(index_uni(lcm_sym295__),
+                              nil_index_list())), "lcm_sym288__"))),
+                    "assigning variable inline_sym36__");
+                  current_statement__ = 80;
+                  lp_accum__.add(log_sum_exp(inline_sym36__));
+                }
+                lcm_sym297__ = last[(inline_sym38__ - 1)];
+                if (logical_gte(lcm_sym297__, (lcm_sym295__ + 1))) {
+                  current_statement__ = 84;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(1,
+                      rvalue(phi,
+                        cons_list(index_uni(inline_sym38__),
+                          cons_list(index_uni(((lcm_sym295__ + 1) - 1)),
+                            nil_index_list())), "phi")));
+                  lcm_sym265__ = ((lcm_sym295__ + 1) + 1);
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(
+                      rvalue(y,
+                        cons_list(index_uni(inline_sym38__),
+                          cons_list(index_uni((lcm_sym295__ + 1)),
+                            nil_index_list())), "y"),
+                      rvalue(lcm_sym288__,
+                        cons_list(index_uni(inline_sym38__),
+                          cons_list(index_uni((lcm_sym295__ + 1)),
+                            nil_index_list())), "lcm_sym288__")));
+                  for (int inline_sym37__ = lcm_sym265__;
+                       inline_sym37__ <= lcm_sym297__; ++inline_sym37__) {
+                    current_statement__ = 84;
+                    lp_accum__.add(
+                      bernoulli_log<propto__>(1,
+                        rvalue(phi,
+                          cons_list(index_uni(inline_sym38__),
+                            cons_list(index_uni((inline_sym37__ - 1)),
+                              nil_index_list())), "phi")));
+                    current_statement__ = 85;
+                    lp_accum__.add(
+                      bernoulli_log<propto__>(
+                        y[(inline_sym38__ - 1)][(inline_sym37__ - 1)],
+                        rvalue(lcm_sym288__,
+                          cons_list(index_uni(inline_sym38__),
+                            cons_list(index_uni(inline_sym37__),
+                              nil_index_list())), "lcm_sym288__")));}
+                } 
+                current_statement__ = 87;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(inline_sym22__,
+                      cons_list(index_uni(inline_sym38__),
+                        cons_list(index_uni(lcm_sym297__), nil_index_list())),
+                      "inline_sym22__")));
+              } else {
+                lcm_sym267__ = (lcm_sym300__ + 1);
+                validate_non_negative_index("lp", "(n_occasions + 1)",
+                                            lcm_sym267__);
+                Eigen::Matrix<local_scalar_t__, -1, 1> inline_sym36__;
+                inline_sym36__ = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym267__);
+                stan::math::fill(inline_sym36__, DUMMY_VAR__);
+                
+                current_statement__ = 89;
+                assign(inline_sym36__,
+                  cons_list(index_uni(1), nil_index_list()),
+                  ((bernoulli_lpmf<false>(1, lcm_sym293__) +
+                     bernoulli_lpmf<false>(0,
+                       rvalue(lcm_sym288__,
+                         cons_list(index_uni(inline_sym38__),
+                           cons_list(index_uni(1), nil_index_list())),
+                         "lcm_sym288__"))) +
+                    bernoulli_lpmf<false>(1,
+                      rvalue(inline_sym22__,
+                        cons_list(index_uni(inline_sym38__),
+                          cons_list(index_uni(1), nil_index_list())),
+                        "inline_sym22__"))),
+                  "assigning variable inline_sym36__");
+                if (logical_gte(lcm_sym300__, 2)) {
+                  current_statement__ = 73;
+                  assign(inline_sym36__,
+                    cons_list(index_uni(2), nil_index_list()),
+                    (((bernoulli_lpmf<false>(1,
+                         prod(
+                           rvalue(lcm_sym242__,
+                             cons_list(index_min_max(1, 1), nil_index_list()),
+                             "lcm_sym242__"))) +
+                        bernoulli_lpmf<false>(1,
+                          rvalue(gamma,
+                            cons_list(index_uni(2), nil_index_list()),
+                            "gamma"))) +
+                       bernoulli_lpmf<false>(0,
+                         rvalue(lcm_sym288__,
+                           cons_list(index_uni(inline_sym38__),
+                             cons_list(index_uni(2), nil_index_list())),
+                           "lcm_sym288__"))) +
+                      bernoulli_lpmf<false>(1,
+                        rvalue(inline_sym22__,
+                          cons_list(index_uni(inline_sym38__),
+                            cons_list(index_uni(2), nil_index_list())),
+                          "inline_sym22__"))),
+                    "assigning variable inline_sym36__");
+                  for (int inline_sym37__ = 3;
+                       inline_sym37__ <= lcm_sym300__; ++inline_sym37__) {
+                    current_statement__ = 73;
+                    assign(inline_sym36__,
+                      cons_list(index_uni(inline_sym37__), nil_index_list()),
+                      (((bernoulli_lpmf<false>(1,
+                           prod(
+                             rvalue(lcm_sym242__,
+                               cons_list(
+                                 index_min_max(1, (inline_sym37__ - 1)),
+                                 nil_index_list()), "lcm_sym242__"))) +
+                          bernoulli_lpmf<false>(1,
+                            gamma[(inline_sym37__ - 1)])) +
+                         bernoulli_lpmf<false>(0,
+                           rvalue(lcm_sym288__,
+                             cons_list(index_uni(inline_sym38__),
+                               cons_list(index_uni(inline_sym37__),
+                                 nil_index_list())), "lcm_sym288__"))) +
+                        bernoulli_lpmf<false>(1,
+                          rvalue(inline_sym22__,
+                            cons_list(index_uni(inline_sym38__),
+                              cons_list(index_uni(inline_sym37__),
+                                nil_index_list())), "inline_sym22__"))),
+                      "assigning variable inline_sym36__");}
+                } 
+                current_statement__ = 74;
+                assign(inline_sym36__,
+                  cons_list(index_uni(lcm_sym267__), nil_index_list()),
+                  bernoulli_lpmf<false>(1, prod(lcm_sym242__)),
+                  "assigning variable inline_sym36__");
+                current_statement__ = 75;
+                lp_accum__.add(log_sum_exp(inline_sym36__));
+              }}
+          } 
+        }
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "inlining_fail2_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      int lcm_sym228__;
+      int lcm_sym227__;
+      double lcm_sym226__;
+      double lcm_sym225__;
+      double lcm_sym224__;
+      double lcm_sym223__;
+      double lcm_sym222__;
+      double lcm_sym221__;
+      int lcm_sym220__;
+      int lcm_sym219__;
+      int lcm_sym218__;
+      int lcm_sym217__;
+      double lcm_sym216__;
+      double lcm_sym215__;
+      double lcm_sym214__;
+      double lcm_sym213__;
+      double lcm_sym212__;
+      double lcm_sym211__;
+      double lcm_sym210__;
+      double lcm_sym209__;
+      local_scalar_t__ lcm_sym172__;
+      double lcm_sym208__;
+      double lcm_sym207__;
+      double lcm_sym206__;
+      double lcm_sym205__;
+      int lcm_sym204__;
+      int lcm_sym203__;
+      int lcm_sym202__;
+      int lcm_sym201__;
+      int lcm_sym197__;
+      int lcm_sym196__;
+      int lcm_sym195__;
+      int lcm_sym194__;
+      int lcm_sym193__;
+      int lcm_sym192__;
+      local_scalar_t__ lcm_sym191__;
+      int lcm_sym190__;
+      double lcm_sym189__;
+      int lcm_sym188__;
+      int lcm_sym187__;
+      int lcm_sym186__;
+      int lcm_sym185__;
+      Eigen::Matrix<double, -1, -1> lcm_sym184__;
+      std::vector<std::vector<int>> lcm_sym183__;
+      local_scalar_t__ lcm_sym182__;
+      local_scalar_t__ lcm_sym181__;
+      local_scalar_t__ lcm_sym180__;
+      local_scalar_t__ lcm_sym179__;
+      local_scalar_t__ lcm_sym178__;
+      local_scalar_t__ lcm_sym177__;
+      double lcm_sym176__;
+      double lcm_sym175__;
+      Eigen::Matrix<double, -1, 1> lcm_sym174__;
+      int lcm_sym173__;
+      int lcm_sym167__;
+      int lcm_sym166__;
+      int lcm_sym165__;
+      int lcm_sym164__;
+      double lcm_sym163__;
+      double lcm_sym162__;
+      int lcm_sym161__;
+      int lcm_sym160__;
+      double lcm_sym159__;
+      double lcm_sym158__;
+      int lcm_sym157__;
+      int lcm_sym156__;
+      int lcm_sym155__;
+      int lcm_sym154__;
+      int lcm_sym153__;
+      int lcm_sym152__;
+      int lcm_sym200__;
+      int lcm_sym150__;
+      int lcm_sym149__;
+      int lcm_sym148__;
+      int lcm_sym147__;
+      int lcm_sym146__;
+      int lcm_sym145__;
+      int lcm_sym144__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym143__;
+      double mean_phi;
+      mean_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mean_phi = in__.scalar();
+      current_statement__ = 1;
+      mean_phi = stan::math::lub_constrain(mean_phi, 0, 1);
+      double mean_p;
+      mean_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      mean_p = in__.scalar();
+      current_statement__ = 2;
+      mean_p = stan::math::lub_constrain(mean_p, 0, 1);
+      current_statement__ = 3;
+      validate_non_negative_index("gamma", "n_occasions", n_occasions);
+      Eigen::Matrix<double, -1, 1> gamma;
+      gamma = Eigen::Matrix<double, -1, 1>(n_occasions);
+      stan::math::fill(gamma, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 3;
+      gamma = in__.vector(n_occasions);
+      lcm_sym145__ = logical_gte(n_occasions, 1);
+      if (lcm_sym145__) {
+        current_statement__ = 3;
+        assign(gamma, cons_list(index_uni(1), nil_index_list()),
+          stan::math::lub_constrain(
+            rvalue(gamma, cons_list(index_uni(1), nil_index_list()), "gamma"),
+            0, 1), "assigning variable gamma");
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          current_statement__ = 3;
+          assign(gamma, cons_list(index_uni(sym1__), nil_index_list()),
+            stan::math::lub_constrain(gamma[(sym1__ - 1)], 0, 1),
+            "assigning variable gamma");}
+      } 
+      lcm_sym200__ = (n_occasions - 1);
+      validate_non_negative_index("epsilon", "(n_occasions - 1)",
+                                  lcm_sym200__);
+      Eigen::Matrix<double, -1, 1> epsilon;
+      epsilon = Eigen::Matrix<double, -1, 1>(lcm_sym200__);
+      stan::math::fill(epsilon, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 4;
+      epsilon = in__.vector(lcm_sym200__);
+      double sigma;
+      sigma = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 5;
+      sigma = in__.scalar();
+      current_statement__ = 5;
+      sigma = stan::math::lub_constrain(sigma, 0, 5);
+      current_statement__ = 6;
+      validate_non_negative_index("phi", "M", M);
+      current_statement__ = 6;
+      validate_non_negative_index("phi", "(n_occasions - 1)", lcm_sym200__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> phi;
+      phi = Eigen::Matrix<local_scalar_t__, -1, -1>(M, lcm_sym200__);
+      stan::math::fill(phi, DUMMY_VAR__);
+      
+      current_statement__ = 7;
+      validate_non_negative_index("p", "M", M);
+      current_statement__ = 7;
+      validate_non_negative_index("p", "n_occasions", n_occasions);
+      Eigen::Matrix<double, -1, -1> p;
+      p = Eigen::Matrix<double, -1, -1>(M, n_occasions);
+      stan::math::fill(p, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 8;
+      validate_non_negative_index("chi", "M", M);
+      current_statement__ = 8;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(M, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      vars__.push_back(mean_phi);
+      vars__.push_back(mean_p);
+      if (lcm_sym145__) {
+        vars__.push_back(
+          rvalue(gamma, cons_list(index_uni(1), nil_index_list()), "gamma"));
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          vars__.push_back(gamma[(sym1__ - 1)]);}
+      } 
+      lcm_sym147__ = logical_gte(lcm_sym200__, 1);
+      if (lcm_sym147__) {
+        vars__.push_back(
+          rvalue(epsilon, cons_list(index_uni(1), nil_index_list()),
+            "epsilon"));
+        for (int sym1__ = 2; sym1__ <= lcm_sym200__; ++sym1__) {
+          vars__.push_back(epsilon[(sym1__ - 1)]);}
+      } 
+      vars__.push_back(sigma);
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      current_statement__ = 11;
+      if (lcm_sym147__) {
+        {
+          lcm_sym144__ = logical_gte(M, 1);
+          if (lcm_sym144__) {
+            lcm_sym182__ = inv_logit(
+                             (logit(mean_phi) +
+                               rvalue(epsilon,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "epsilon")));
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), lcm_sym182__,
+              "assigning variable phi");
+            for (int i = 2; i <= M; ++i) {
+              current_statement__ = 9;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(1), nil_index_list())), lcm_sym182__,
+                "assigning variable phi");}
+          } 
+          for (int t = 2; t <= lcm_sym200__; ++t) {
+            current_statement__ = 10;
+            if (lcm_sym144__) {
+              lcm_sym181__ = inv_logit(
+                               (logit(mean_phi) +
+                                 rvalue(epsilon,
+                                   cons_list(index_uni(t), nil_index_list()),
+                                   "epsilon")));
+              assign(phi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(t), nil_index_list())), lcm_sym181__,
+                "assigning variable phi");
+              for (int i = 2; i <= M; ++i) {
+                current_statement__ = 9;
+                assign(phi,
+                  cons_list(index_uni(i),
+                    cons_list(index_uni(t), nil_index_list())), lcm_sym181__,
+                  "assigning variable phi");}
+            } }
+        }
+      } else {
+        lcm_sym144__ = logical_gte(M, 1);
+      }
+      assign(lcm_sym184__, nil_index_list(),
+        rep_matrix(mean_p, M, n_occasions), "assigning variable lcm_sym184__");
+      assign(p, nil_index_list(), lcm_sym184__, "assigning variable p");
+      Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym1__;
+      int inline_sym9__;
+      inline_sym9__ = std::numeric_limits<int>::min();
+      
+      inline_sym9__ = 0;
+      for (int inline_sym10__ = 1; inline_sym10__ <= 1; ++inline_sym10__) {
+        int inline_sym2__;
+        inline_sym2__ = std::numeric_limits<int>::min();
+        
+        lcm_sym186__ = rows(lcm_sym184__);
+        int inline_sym3__;
+        inline_sym3__ = std::numeric_limits<int>::min();
+        
+        lcm_sym173__ = cols(lcm_sym184__);
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "n_ind", lcm_sym186__);
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "n_occasions", lcm_sym173__);
+        Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym4__;
+        inline_sym4__ = Eigen::Matrix<local_scalar_t__, -1, -1>(lcm_sym186__, lcm_sym173__);
+        stan::math::fill(inline_sym4__, DUMMY_VAR__);
+        
+        for (int inline_sym8__ = 1; inline_sym8__ <= lcm_sym186__;
+             ++inline_sym8__) {
+          current_statement__ = 15;
+          assign(inline_sym4__,
+            cons_list(index_uni(inline_sym8__),
+              cons_list(index_uni(lcm_sym173__), nil_index_list())), 1.0,
+            "assigning variable inline_sym4__");
+          lcm_sym155__ = (lcm_sym173__ - 1);
+          if (logical_gte(lcm_sym155__, 1)) {
+            int inline_sym5__;
+            inline_sym5__ = std::numeric_limits<int>::min();
+            
+            int inline_sym6__;
+            inline_sym6__ = std::numeric_limits<int>::min();
+            
+            lcm_sym161__ = (lcm_sym155__ + 1);
+            current_statement__ = 18;
+            assign(inline_sym4__,
+              cons_list(index_uni(inline_sym8__),
+                cons_list(index_uni(lcm_sym155__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(inline_sym8__),
+                     cons_list(index_uni(lcm_sym155__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(lcm_sym184__,
+                      cons_list(index_uni(inline_sym8__),
+                        cons_list(index_uni(lcm_sym161__), nil_index_list())),
+                      "lcm_sym184__"))),
+                rvalue(inline_sym4__,
+                  cons_list(index_uni(inline_sym8__),
+                    cons_list(index_uni(lcm_sym161__), nil_index_list())),
+                  "inline_sym4__"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(inline_sym8__),
+                      cons_list(index_uni(lcm_sym155__), nil_index_list())),
+                    "phi"))), "assigning variable inline_sym4__");
+            for (int inline_sym7__ = 2; inline_sym7__ <= lcm_sym155__;
+                 ++inline_sym7__) {
+              int inline_sym5__;
+              inline_sym5__ = std::numeric_limits<int>::min();
+              
+              lcm_sym154__ = (lcm_sym173__ - inline_sym7__);
+              int inline_sym6__;
+              inline_sym6__ = std::numeric_limits<int>::min();
+              
+              lcm_sym160__ = (lcm_sym154__ + 1);
+              current_statement__ = 18;
+              assign(inline_sym4__,
+                cons_list(index_uni(inline_sym8__),
+                  cons_list(index_uni(lcm_sym154__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(inline_sym8__),
+                       cons_list(index_uni(lcm_sym154__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(lcm_sym184__,
+                        cons_list(index_uni(inline_sym8__),
+                          cons_list(index_uni(lcm_sym160__),
+                            nil_index_list())), "lcm_sym184__"))),
+                  rvalue(inline_sym4__,
+                    cons_list(index_uni(inline_sym8__),
+                      cons_list(index_uni(lcm_sym160__), nil_index_list())),
+                    "inline_sym4__"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(inline_sym8__),
+                        cons_list(index_uni(lcm_sym154__), nil_index_list())),
+                      "phi"))), "assigning variable inline_sym4__");}
+          } 
+          if (inline_sym9__) {
+            break;
+          } }
+        if (inline_sym9__) {
+          break;
+        } 
+        inline_sym9__ = 1;
+        assign(inline_sym1__, nil_index_list(), inline_sym4__,
+          "assigning variable inline_sym1__");
+        break;}
+      assign(chi, nil_index_list(), inline_sym1__, "assigning variable chi");
+      if (lcm_sym147__) {
+        if (lcm_sym144__) {
+          vars__.push_back(
+            rvalue(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "phi"));
+          for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+            vars__.push_back(
+              rvalue(phi,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "phi"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= lcm_sym200__; ++sym1__) {
+          if (lcm_sym144__) {
+            vars__.push_back(
+              rvalue(phi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())), "phi"));
+            for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+              vars__.push_back(
+                rvalue(phi,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())), "phi"));
+            }
+          } }
+      } 
+      if (lcm_sym145__) {
+        if (lcm_sym144__) {
+          vars__.push_back(
+            rvalue(lcm_sym184__,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "lcm_sym184__"));
+          for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+            vars__.push_back(
+              rvalue(lcm_sym184__,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "lcm_sym184__"));
+          }
+        } 
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          if (lcm_sym144__) {
+            vars__.push_back(
+              rvalue(lcm_sym184__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                "lcm_sym184__"));
+            for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+              vars__.push_back(
+                rvalue(lcm_sym184__,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  "lcm_sym184__"));}
+          } }
+      } 
+      if (lcm_sym145__) {
+        if (lcm_sym144__) {
+          vars__.push_back(
+            rvalue(inline_sym1__,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "inline_sym1__"));
+          for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+            vars__.push_back(
+              rvalue(inline_sym1__,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())),
+                "inline_sym1__"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          if (lcm_sym144__) {
+            vars__.push_back(
+              rvalue(inline_sym1__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                "inline_sym1__"));
+            for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+              vars__.push_back(
+                rvalue(inline_sym1__,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  "inline_sym1__"));}
+          } }
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+      double sigma2;
+      sigma2 = std::numeric_limits<double>::quiet_NaN();
+      
+      local_scalar_t__ psi;
+      psi = DUMMY_VAR__;
+      
+      current_statement__ = 24;
+      validate_non_negative_index("b", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, 1> b;
+      b = Eigen::Matrix<local_scalar_t__, -1, 1>(n_occasions);
+      stan::math::fill(b, DUMMY_VAR__);
+      
+      int Nsuper;
+      Nsuper = std::numeric_limits<int>::min();
+      
+      current_statement__ = 26;
+      validate_non_negative_index("N", "n_occasions", n_occasions);
+      std::vector<int> N;
+      N = std::vector<int>(n_occasions, std::numeric_limits<int>::min());
+      
+      current_statement__ = 27;
+      validate_non_negative_index("B", "n_occasions", n_occasions);
+      std::vector<int> B;
+      B = std::vector<int>(n_occasions, std::numeric_limits<int>::min());
+      
+      current_statement__ = 28;
+      validate_non_negative_index("z", "M", M);
+      current_statement__ = 28;
+      validate_non_negative_index("z", "n_occasions", n_occasions);
+      std::vector<std::vector<int>> z;
+      z = std::vector<std::vector<int>>(M, std::vector<int>(n_occasions, std::numeric_limits<int>::min()));
+      
+      current_statement__ = 37;
+      if (lcm_sym144__) {
+        int q;
+        q = std::numeric_limits<int>::min();
+        
+        double mu2;
+        mu2 = std::numeric_limits<double>::quiet_NaN();
+        
+        lcm_sym172__ = rvalue(gamma,
+                         cons_list(index_uni(1), nil_index_list()), "gamma");
+        assign(z,
+          cons_list(index_uni(1), cons_list(index_uni(1), nil_index_list())),
+          bernoulli_rng(lcm_sym172__, base_rng__), "assigning variable z");
+        lcm_sym146__ = logical_gte(n_occasions, 2);
+        if (lcm_sym146__) {
+          lcm_sym220__ = rvalue(z,
+                           cons_list(index_uni(1),
+                             cons_list(index_uni(1), nil_index_list())), "z");
+          lcm_sym167__ = (1 * (1 - lcm_sym220__));
+          q = lcm_sym167__;
+          lcm_sym179__ = stan::math::fma(
+                           rvalue(phi,
+                             cons_list(index_uni(1),
+                               cons_list(index_uni(1), nil_index_list())),
+                             "phi"), lcm_sym220__,
+                           (rvalue(gamma,
+                              cons_list(index_uni(2), nil_index_list()),
+                              "gamma") * lcm_sym167__));
+          current_statement__ = 31;
+          assign(z,
+            cons_list(index_uni(1),
+              cons_list(index_uni(2), nil_index_list())),
+            bernoulli_rng(lcm_sym179__, base_rng__), "assigning variable z");
+          for (int t = 3; t <= n_occasions; ++t) {
+            current_statement__ = 32;
+            q = (q *
+                  (1 -
+                    rvalue(z,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((t - 1)), nil_index_list())),
+                      "z")));
+            lcm_sym180__ = stan::math::fma(
+                             rvalue(phi,
+                               cons_list(index_uni(1),
+                                 cons_list(index_uni((t - 1)),
+                                   nil_index_list())), "phi"),
+                             rvalue(z,
+                               cons_list(index_uni(1),
+                                 cons_list(index_uni((t - 1)),
+                                   nil_index_list())), "z"),
+                             (rvalue(gamma,
+                                cons_list(index_uni(t), nil_index_list()),
+                                "gamma") * q));
+            current_statement__ = 31;
+            assign(z,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())),
+              bernoulli_rng(lcm_sym180__, base_rng__), "assigning variable z");
+          }
+        } 
+        for (int i = 2; i <= M; ++i) {
+          int q;
+          q = std::numeric_limits<int>::min();
+          
+          double mu2;
+          mu2 = std::numeric_limits<double>::quiet_NaN();
+          
+          current_statement__ = 34;
+          assign(z,
+            cons_list(index_uni(i),
+              cons_list(index_uni(1), nil_index_list())),
+            bernoulli_rng(lcm_sym172__, base_rng__), "assigning variable z");
+          current_statement__ = 35;
+          if (lcm_sym146__) {
+            lcm_sym166__ = (1 *
+                             (1 -
+                               rvalue(z,
+                                 cons_list(index_uni(i),
+                                   cons_list(index_uni(1), nil_index_list())),
+                                 "z")));
+            q = lcm_sym166__;
+            lcm_sym177__ = stan::math::fma(
+                             rvalue(phi,
+                               cons_list(index_uni(i),
+                                 cons_list(index_uni(1), nil_index_list())),
+                               "phi"),
+                             rvalue(z,
+                               cons_list(index_uni(i),
+                                 cons_list(index_uni(1), nil_index_list())),
+                               "z"),
+                             (rvalue(gamma,
+                                cons_list(index_uni(2), nil_index_list()),
+                                "gamma") * lcm_sym166__));
+            current_statement__ = 31;
+            assign(z,
+              cons_list(index_uni(i),
+                cons_list(index_uni(2), nil_index_list())),
+              bernoulli_rng(lcm_sym177__, base_rng__), "assigning variable z");
+            for (int t = 3; t <= n_occasions; ++t) {
+              current_statement__ = 32;
+              q = (q *
+                    (1 -
+                      rvalue(z,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((t - 1)), nil_index_list())),
+                        "z")));
+              lcm_sym178__ = stan::math::fma(
+                               rvalue(phi,
+                                 cons_list(index_uni(i),
+                                   cons_list(index_uni((t - 1)),
+                                     nil_index_list())), "phi"),
+                               rvalue(z,
+                                 cons_list(index_uni(i),
+                                   cons_list(index_uni((t - 1)),
+                                     nil_index_list())), "z"),
+                               (rvalue(gamma,
+                                  cons_list(index_uni(t), nil_index_list()),
+                                  "gamma") * q));
+              current_statement__ = 31;
+              assign(z,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())),
+                bernoulli_rng(lcm_sym178__, base_rng__),
+                "assigning variable z");}
+          } }
+      } 
+      {
+        current_statement__ = 38;
+        validate_non_negative_index("cprob", "n_occasions", n_occasions);
+        Eigen::Matrix<double, -1, 1> cprob;
+        cprob = Eigen::Matrix<double, -1, 1>(n_occasions);
+        stan::math::fill(cprob, std::numeric_limits<double>::quiet_NaN());
+        
+        Eigen::Matrix<local_scalar_t__, -1, 1> inline_sym11__;
+        int inline_sym16__;
+        inline_sym16__ = std::numeric_limits<int>::min();
+        
+        inline_sym16__ = 0;
+        for (int inline_sym17__ = 1; inline_sym17__ <= 1; ++inline_sym17__) {
+          int inline_sym12__;
+          inline_sym12__ = std::numeric_limits<int>::min();
+          
+          lcm_sym185__ = rows(gamma);
+          current_statement__ = 40;
+          validate_non_negative_index("log_cprob", "N", lcm_sym185__);
+          Eigen::Matrix<local_scalar_t__, -1, 1> inline_sym13__;
+          inline_sym13__ = Eigen::Matrix<local_scalar_t__, -1, 1>(lcm_sym185__);
+          stan::math::fill(inline_sym13__, DUMMY_VAR__);
+          
+          local_scalar_t__ inline_sym14__;
+          inline_sym14__ = DUMMY_VAR__;
+          
+          if (logical_gte(lcm_sym185__, 1)) {
+            lcm_sym172__ = rvalue(gamma,
+                             cons_list(index_uni(1), nil_index_list()),
+                             "gamma");
+            assign(inline_sym13__, cons_list(index_uni(1), nil_index_list()),
+              (stan::math::log(lcm_sym172__) + 0),
+              "assigning variable inline_sym13__");
+            current_statement__ = 42;
+            inline_sym14__ = (0 + log1m(lcm_sym172__));
+            for (int inline_sym15__ = 2; inline_sym15__ <= lcm_sym185__;
+                 ++inline_sym15__) {
+              current_statement__ = 43;
+              assign(inline_sym13__,
+                cons_list(index_uni(inline_sym15__), nil_index_list()),
+                (stan::math::log(gamma[(inline_sym15__ - 1)]) +
+                  inline_sym14__), "assigning variable inline_sym13__");
+              current_statement__ = 42;
+              inline_sym14__ = (inline_sym14__ +
+                                 log1m(gamma[(inline_sym15__ - 1)]));}
+          } 
+          if (inline_sym16__) {
+            break;
+          } 
+          inline_sym16__ = 1;
+          assign(inline_sym11__, nil_index_list(),
+            stan::math::exp(inline_sym13__),
+            "assigning variable inline_sym11__");
+          break;}
+        current_statement__ = 46;
+        validate_non_negative_index("recruit", "M", M);
+        current_statement__ = 46;
+        validate_non_negative_index("recruit", "n_occasions", n_occasions);
+        std::vector<std::vector<int>> recruit;
+        recruit = std::vector<std::vector<int>>(M, std::vector<int>(n_occasions, std::numeric_limits<int>::min()));
+        
+        current_statement__ = 46;
+        assign(recruit, nil_index_list(), rep_array(0, M, n_occasions),
+          "assigning variable recruit");
+        current_statement__ = 47;
+        validate_non_negative_index("Nind", "M", M);
+        std::vector<int> Nind;
+        Nind = std::vector<int>(M, std::numeric_limits<int>::min());
+        
+        current_statement__ = 48;
+        validate_non_negative_index("Nalive", "M", M);
+        std::vector<int> Nalive;
+        Nalive = std::vector<int>(M, std::numeric_limits<int>::min());
+        
+        lcm_sym189__ = square(sigma);
+        sigma2 = lcm_sym189__;
+        lcm_sym191__ = sum(inline_sym11__);
+        psi = lcm_sym191__;
+        assign(lcm_sym143__, nil_index_list(),
+          divide(inline_sym11__, lcm_sym191__),
+          "assigning variable lcm_sym143__");
+        assign(b, nil_index_list(), lcm_sym143__, "assigning variable b");
+        current_statement__ = 56;
+        if (lcm_sym144__) {
+          int f;
+          f = std::numeric_limits<int>::min();
+          
+          int inline_sym18__;
+          int inline_sym20__;
+          inline_sym20__ = std::numeric_limits<int>::min();
+          
+          inline_sym20__ = 0;
+          for (int inline_sym21__ = 1; inline_sym21__ <= 1; ++inline_sym21__) {
+            lcm_sym188__ = size(
+                             rvalue(z,
+                               cons_list(index_uni(1), nil_index_list()),
+                               "z"));
+            for (int inline_sym19__ = 1; inline_sym19__ <= lcm_sym188__;
+                 ++inline_sym19__) {
+              current_statement__ = 51;
+              if (rvalue(z,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(inline_sym19__), nil_index_list())),
+                    "z")) {
+                inline_sym20__ = 1;
+                inline_sym18__ = inline_sym19__;
+                break;
+              } }
+            if (inline_sym20__) {
+              break;
+            } 
+            inline_sym20__ = 1;
+            inline_sym18__ = 0;
+            break;}
+          current_statement__ = 54;
+          if (logical_gt(inline_sym18__, 0)) {
+            current_statement__ = 53;
+            assign(recruit,
+              cons_list(index_uni(1),
+                cons_list(index_uni(inline_sym18__), nil_index_list())), 1,
+              "assigning variable recruit");
+          } 
+          for (int i = 2; i <= M; ++i) {
+            int f;
+            f = std::numeric_limits<int>::min();
+            
+            int inline_sym18__;
+            int inline_sym20__;
+            inline_sym20__ = std::numeric_limits<int>::min();
+            
+            inline_sym20__ = 0;
+            for (int inline_sym21__ = 1; inline_sym21__ <= 1;
+                 ++inline_sym21__) {
+              lcm_sym187__ = size(
+                               rvalue(z,
+                                 cons_list(index_uni(i), nil_index_list()),
+                                 "z"));
+              for (int inline_sym19__ = 1; inline_sym19__ <= lcm_sym187__;
+                   ++inline_sym19__) {
+                current_statement__ = 51;
+                if (rvalue(z,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(inline_sym19__),
+                          nil_index_list())), "z")) {
+                  inline_sym20__ = 1;
+                  inline_sym18__ = inline_sym19__;
+                  break;
+                } }
+              if (inline_sym20__) {
+                break;
+              } 
+              inline_sym20__ = 1;
+              inline_sym18__ = 0;
+              break;}
+            current_statement__ = 54;
+            if (logical_gt(inline_sym18__, 0)) {
+              current_statement__ = 53;
+              assign(recruit,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(inline_sym18__), nil_index_list())), 1,
+                "assigning variable recruit");
+            } }
+        } 
+        current_statement__ = 60;
+        if (lcm_sym145__) {
+          current_statement__ = 57;
+          assign(N, cons_list(index_uni(1), nil_index_list()),
+            sum(
+              rvalue(z,
+                cons_list(index_omni(),
+                  cons_list(index_uni(1), nil_index_list())), "z")),
+            "assigning variable N");
+          current_statement__ = 58;
+          assign(B, cons_list(index_uni(1), nil_index_list()),
+            sum(
+              rvalue(recruit,
+                cons_list(index_omni(),
+                  cons_list(index_uni(1), nil_index_list())), "recruit")),
+            "assigning variable B");
+          for (int t = 2; t <= n_occasions; ++t) {
+            current_statement__ = 57;
+            assign(N, cons_list(index_uni(t), nil_index_list()),
+              sum(
+                rvalue(z,
+                  cons_list(index_omni(),
+                    cons_list(index_uni(t), nil_index_list())), "z")),
+              "assigning variable N");
+            current_statement__ = 58;
+            assign(B, cons_list(index_uni(t), nil_index_list()),
+              sum(
+                rvalue(recruit,
+                  cons_list(index_omni(),
+                    cons_list(index_uni(t), nil_index_list())), "recruit")),
+              "assigning variable B");}
+        } 
+        current_statement__ = 64;
+        if (lcm_sym144__) {
+          current_statement__ = 61;
+          assign(Nind, cons_list(index_uni(1), nil_index_list()),
+            sum(rvalue(z, cons_list(index_uni(1), nil_index_list()), "z")),
+            "assigning variable Nind");
+          current_statement__ = 62;
+          assign(Nalive, cons_list(index_uni(1), nil_index_list()),
+            (1 -
+              logical_negation(
+                rvalue(Nind, cons_list(index_uni(1), nil_index_list()),
+                  "Nind"))), "assigning variable Nalive");
+          for (int i = 2; i <= M; ++i) {
+            current_statement__ = 61;
+            assign(Nind, cons_list(index_uni(i), nil_index_list()),
+              sum(rvalue(z, cons_list(index_uni(i), nil_index_list()), "z")),
+              "assigning variable Nind");
+            current_statement__ = 62;
+            assign(Nalive, cons_list(index_uni(i), nil_index_list()),
+              (1 -
+                logical_negation(
+                  rvalue(Nind, cons_list(index_uni(i), nil_index_list()),
+                    "Nind"))), "assigning variable Nalive");}
+        } 
+        current_statement__ = 65;
+        Nsuper = sum(Nalive);
+      }
+      vars__.push_back(lcm_sym189__);
+      vars__.push_back(lcm_sym191__);
+      if (lcm_sym145__) {
+        vars__.push_back(
+          rvalue(lcm_sym143__, cons_list(index_uni(1), nil_index_list()),
+            "lcm_sym143__"));
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          vars__.push_back(lcm_sym143__[(sym1__ - 1)]);}
+      } 
+      vars__.push_back(Nsuper);
+      if (lcm_sym145__) {
+        vars__.push_back(
+          rvalue(N, cons_list(index_uni(1), nil_index_list()), "N"));
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          vars__.push_back(N[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym145__) {
+        vars__.push_back(
+          rvalue(B, cons_list(index_uni(1), nil_index_list()), "B"));
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          vars__.push_back(B[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym145__) {
+        if (lcm_sym144__) {
+          vars__.push_back(
+            rvalue(z,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "z"));
+          for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+            vars__.push_back(
+              rvalue(z,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "z"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          if (lcm_sym144__) {
+            vars__.push_back(
+              rvalue(z,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())), "z"));
+            for (int sym2__ = 2; sym2__ <= M; ++sym2__) {
+              vars__.push_back(z[(sym2__ - 1)][(sym1__ - 1)]);}
+          } }
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym142__;
+      double lcm_sym141__;
+      double lcm_sym140__;
+      double lcm_sym139__;
+      double lcm_sym138__;
+      double lcm_sym137__;
+      double lcm_sym136__;
+      double lcm_sym135__;
+      int lcm_sym132__;
+      int lcm_sym131__;
+      int lcm_sym130__;
+      int lcm_sym129__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double mean_phi;
+      mean_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mean_phi = context__.vals_r("mean_phi")[(1 - 1)];
+      current_statement__ = 1;
+      mean_phi = stan::math::lub_free(mean_phi, 0, 1);
+      double mean_p;
+      mean_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      mean_p = context__.vals_r("mean_p")[(1 - 1)];
+      current_statement__ = 2;
+      mean_p = stan::math::lub_free(mean_p, 0, 1);
+      current_statement__ = 3;
+      validate_non_negative_index("gamma", "n_occasions", n_occasions);
+      Eigen::Matrix<double, -1, 1> gamma;
+      gamma = Eigen::Matrix<double, -1, 1>(n_occasions);
+      stan::math::fill(gamma, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> gamma_flat__;
+        current_statement__ = 3;
+        assign(gamma_flat__, nil_index_list(), context__.vals_r("gamma"),
+          "assigning variable gamma_flat__");
+        current_statement__ = 3;
+        pos__ = 1;
+        lcm_sym129__ = logical_gte(n_occasions, 1);
+        if (lcm_sym129__) {
+          current_statement__ = 3;
+          assign(gamma, cons_list(index_uni(1), nil_index_list()),
+            rvalue(gamma_flat__, cons_list(index_uni(1), nil_index_list()),
+              "gamma_flat__"), "assigning variable gamma");
+          current_statement__ = 3;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+            current_statement__ = 3;
+            assign(gamma, cons_list(index_uni(sym1__), nil_index_list()),
+              gamma_flat__[(pos__ - 1)], "assigning variable gamma");
+            current_statement__ = 3;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 3;
+      if (lcm_sym129__) {
+        current_statement__ = 3;
+        assign(gamma, cons_list(index_uni(1), nil_index_list()),
+          stan::math::lub_free(
+            rvalue(gamma, cons_list(index_uni(1), nil_index_list()), "gamma"),
+            0, 1), "assigning variable gamma");
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          current_statement__ = 3;
+          assign(gamma, cons_list(index_uni(sym1__), nil_index_list()),
+            stan::math::lub_free(gamma[(sym1__ - 1)], 0, 1),
+            "assigning variable gamma");}
+      } 
+      lcm_sym131__ = (n_occasions - 1);
+      validate_non_negative_index("epsilon", "(n_occasions - 1)",
+                                  lcm_sym131__);
+      Eigen::Matrix<double, -1, 1> epsilon;
+      epsilon = Eigen::Matrix<double, -1, 1>(lcm_sym131__);
+      stan::math::fill(epsilon, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> epsilon_flat__;
+        current_statement__ = 4;
+        assign(epsilon_flat__, nil_index_list(), context__.vals_r("epsilon"),
+          "assigning variable epsilon_flat__");
+        current_statement__ = 4;
+        pos__ = 1;
+        lcm_sym130__ = logical_gte(lcm_sym131__, 1);
+        if (lcm_sym130__) {
+          current_statement__ = 4;
+          assign(epsilon, cons_list(index_uni(1), nil_index_list()),
+            rvalue(epsilon_flat__, cons_list(index_uni(1), nil_index_list()),
+              "epsilon_flat__"), "assigning variable epsilon");
+          current_statement__ = 4;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= lcm_sym131__; ++sym1__) {
+            current_statement__ = 4;
+            assign(epsilon, cons_list(index_uni(sym1__), nil_index_list()),
+              epsilon_flat__[(pos__ - 1)], "assigning variable epsilon");
+            current_statement__ = 4;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      double sigma;
+      sigma = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 5;
+      sigma = context__.vals_r("sigma")[(1 - 1)];
+      current_statement__ = 5;
+      sigma = stan::math::lub_free(sigma, 0, 5);
+      vars__.push_back(mean_phi);
+      vars__.push_back(mean_p);
+      if (lcm_sym129__) {
+        vars__.push_back(
+          rvalue(gamma, cons_list(index_uni(1), nil_index_list()), "gamma"));
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          vars__.push_back(gamma[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym130__) {
+        vars__.push_back(
+          rvalue(epsilon, cons_list(index_uni(1), nil_index_list()),
+            "epsilon"));
+        for (int sym1__ = 2; sym1__ <= lcm_sym131__; ++sym1__) {
+          vars__.push_back(epsilon[(sym1__ - 1)]);}
+      } 
+      vars__.push_back(sigma);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("mean_phi");
+    names__.push_back("mean_p");
+    names__.push_back("gamma");
+    names__.push_back("epsilon");
+    names__.push_back("sigma");
+    names__.push_back("phi");
+    names__.push_back("p");
+    names__.push_back("chi");
+    names__.push_back("sigma2");
+    names__.push_back("psi");
+    names__.push_back("b");
+    names__.push_back("Nsuper");
+    names__.push_back("N");
+    names__.push_back("B");
+    names__.push_back("z");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back((n_occasions - 1));
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(M);
+    
+    dims__.push_back((n_occasions - 1));
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(M);
+    
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(M);
+    
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(M);
+    
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mean_phi");
+    param_names__.push_back(std::string() + "mean_p");
+    for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+      {
+        param_names__.push_back(std::string() + "gamma" + '.' + std::to_string(sym324__));
+      }}
+    for (int sym324__ = 1; sym324__ <= (n_occasions - 1); ++sym324__) {
+      {
+        param_names__.push_back(std::string() + "epsilon" + '.' + std::to_string(sym324__));
+      }}
+    param_names__.push_back(std::string() + "sigma");
+    if (emit_transformed_parameters__) {
+      for (int sym324__ = 1; sym324__ <= (n_occasions - 1); ++sym324__) {
+        {
+          for (int sym325__ = 1; sym325__ <= M; ++sym325__) {
+            {
+              param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym325__) + '.' + std::to_string(sym324__));
+            }}
+        }}
+      for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+        {
+          for (int sym325__ = 1; sym325__ <= M; ++sym325__) {
+            {
+              param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym325__) + '.' + std::to_string(sym324__));
+            }}
+        }}
+      for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+        {
+          for (int sym325__ = 1; sym325__ <= M; ++sym325__) {
+            {
+              param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym325__) + '.' + std::to_string(sym324__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      param_names__.push_back(std::string() + "sigma2");
+      param_names__.push_back(std::string() + "psi");
+      for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+        {
+          param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym324__));
+        }}
+      param_names__.push_back(std::string() + "Nsuper");
+      for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+        {
+          param_names__.push_back(std::string() + "N" + '.' + std::to_string(sym324__));
+        }}
+      for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+        {
+          param_names__.push_back(std::string() + "B" + '.' + std::to_string(sym324__));
+        }}
+      for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+        {
+          for (int sym325__ = 1; sym325__ <= M; ++sym325__) {
+            {
+              param_names__.push_back(std::string() + "z" + '.' + std::to_string(sym325__) + '.' + std::to_string(sym324__));
+            }}
+        }}
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mean_phi");
+    param_names__.push_back(std::string() + "mean_p");
+    for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+      {
+        param_names__.push_back(std::string() + "gamma" + '.' + std::to_string(sym324__));
+      }}
+    for (int sym324__ = 1; sym324__ <= (n_occasions - 1); ++sym324__) {
+      {
+        param_names__.push_back(std::string() + "epsilon" + '.' + std::to_string(sym324__));
+      }}
+    param_names__.push_back(std::string() + "sigma");
+    if (emit_transformed_parameters__) {
+      for (int sym324__ = 1; sym324__ <= (n_occasions - 1); ++sym324__) {
+        {
+          for (int sym325__ = 1; sym325__ <= M; ++sym325__) {
+            {
+              param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym325__) + '.' + std::to_string(sym324__));
+            }}
+        }}
+      for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+        {
+          for (int sym325__ = 1; sym325__ <= M; ++sym325__) {
+            {
+              param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym325__) + '.' + std::to_string(sym324__));
+            }}
+        }}
+      for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+        {
+          for (int sym325__ = 1; sym325__ <= M; ++sym325__) {
+            {
+              param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym325__) + '.' + std::to_string(sym324__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      param_names__.push_back(std::string() + "sigma2");
+      param_names__.push_back(std::string() + "psi");
+      for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+        {
+          param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym324__));
+        }}
+      param_names__.push_back(std::string() + "Nsuper");
+      for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+        {
+          param_names__.push_back(std::string() + "N" + '.' + std::to_string(sym324__));
+        }}
+      for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+        {
+          param_names__.push_back(std::string() + "B" + '.' + std::to_string(sym324__));
+        }}
+      for (int sym324__ = 1; sym324__ <= n_occasions; ++sym324__) {
+        {
+          for (int sym325__ = 1; sym325__ <= M; ++sym325__) {
+            {
+              param_names__.push_back(std::string() + "z" + '.' + std::to_string(sym325__) + '.' + std::to_string(sym324__));
+            }}
+        }}
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"gamma\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"parameters\"},{\"name\":\"epsilon\",\"type\":{\"name\":\"vector\",\"length\":" << (n_occasions - 1) << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << (n_occasions - 1) << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"psi\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"generated_quantities\"},{\"name\":\"Nsuper\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"},{\"name\":\"N\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"B\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"z\",\"type\":{\"name\":\"array\",\"length\":" << M << ",\"element_type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}}},\"block\":\"generated_quantities\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"gamma\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"parameters\"},{\"name\":\"epsilon\",\"type\":{\"name\":\"vector\",\"length\":" << (n_occasions - 1) << "},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << (n_occasions - 1) << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << M << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"},{\"name\":\"sigma2\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"psi\",\"type\":{\"name\":\"real\"},\"block\":\"generated_quantities\"},{\"name\":\"b\",\"type\":{\"name\":\"vector\",\"length\":" << n_occasions << "},\"block\":\"generated_quantities\"},{\"name\":\"Nsuper\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"},{\"name\":\"N\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"B\",\"type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"},{\"name\":\"z\",\"type\":{\"name\":\"array\",\"length\":" << M << ",\"element_type\":{\"name\":\"array\",\"length\":" << n_occasions << ",\"element_type\":{\"name\":\"int\"}}},\"block\":\"generated_quantities\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef inlining_fail2_model_namespace::inlining_fail2_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp lcm-experiment.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace lcm_experiment_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'lcm-experiment.stan', line 2, column 2 to column 8)",
+                                                      " (in 'lcm-experiment.stan', line 5, column 2 to column 13)",
+                                                      " (in 'lcm-experiment.stan', line 6, column 2 to column 9)",
+                                                      " (in 'lcm-experiment.stan', line 8, column 4 to column 27)",
+                                                      " (in 'lcm-experiment.stan', line 7, column 2 to line 10, column 3)",
+                                                      " (in 'lcm-experiment.stan', line 11, column 2 to column 38)"};
+
+
+
+class lcm_experiment_model : public model_base_crtp<lcm_experiment_model> {
+
+ private:
+  double lcm_sym3__;
+  int pos__;
+  int j;
+  double z;
+  double x;
+  double i;
+ 
+ public:
+  ~lcm_experiment_model() { }
+  
+  std::string model_name() const { return "lcm_experiment_model"; }
+  
+  lcm_experiment_model(stan::io::var_context& context__,
+                       unsigned int random_seed__ = 0,
+                       std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "lcm_experiment_model_namespace::lcm_experiment_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","j","int",
+          context__.to_vec());
+      j = std::numeric_limits<int>::min();
+      
+      current_statement__ = 1;
+      j = context__.vals_i("j")[(1 - 1)];
+      z = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      z = 1;
+      x = std::numeric_limits<double>::quiet_NaN();
+      
+      {
+        current_statement__ = 4;
+        x = normal_rng(123, 1, base_rng__);
+        lcm_sym3__ = stan::math::fma(stan::math::sqrt(j), 2, 1);
+        z = normal_rng(lcm_sym3__, 1, base_rng__);
+      }
+      i = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 6;
+      i = normal_rng(lcm_sym3__, 1, base_rng__);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "lcm_experiment_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "lcm_experiment_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      int lcm_sym2__;
+      int lcm_sym1__;
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef lcm_experiment_model_namespace::lcm_experiment_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp lcm-experiment2.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace lcm_experiment2_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'lcm-experiment2.stan', line 2, column 2 to column 9)",
+                                                      " (in 'lcm-experiment2.stan', line 5, column 2 to column 18)",
+                                                      " (in 'lcm-experiment2.stan', line 7, column 4 to column 11)",
+                                                      " (in 'lcm-experiment2.stan', line 6, column 2 to line 8, column 3)",
+                                                      " (in 'lcm-experiment2.stan', line 10, column 4 to column 11)",
+                                                      " (in 'lcm-experiment2.stan', line 9, column 2 to line 10, column 11)",
+                                                      " (in 'lcm-experiment2.stan', line 11, column 2 to column 14)"};
+
+
+
+class lcm_experiment2_model : public model_base_crtp<lcm_experiment2_model> {
+
+ private:
+  int pos__;
+ 
+ public:
+  ~lcm_experiment2_model() { }
+  
+  std::string model_name() const { return "lcm_experiment2_model"; }
+  
+  lcm_experiment2_model(stan::io::var_context& context__,
+                        unsigned int random_seed__ = 0,
+                        std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "lcm_experiment2_model_namespace::lcm_experiment2_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "lcm_experiment2_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      local_scalar_t__ lcm_sym5__;
+      double lcm_sym4__;
+      double lcm_sym3__;
+      local_scalar_t__ x;
+      x = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      x = in__.scalar();
+      {
+        local_scalar_t__ y;
+        y = DUMMY_VAR__;
+        
+        lcm_sym5__ = stan::math::log(x);
+        {
+          current_statement__ = 3;
+          y = (lcm_sym5__ + 1);
+        }
+        {
+          current_statement__ = 5;
+          y = (y + 1);
+        }
+        current_statement__ = 7;
+        lp_accum__.add(y);
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "lcm_experiment2_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      int lcm_sym2__;
+      int lcm_sym1__;
+      double x;
+      x = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      x = in__.scalar();
+      vars__.push_back(x);
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double x;
+      x = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      x = context__.vals_r("x")[(1 - 1)];
+      vars__.push_back(x);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("x");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "x");
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "x");
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"x\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"x\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef lcm_experiment2_model_namespace::lcm_experiment2_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp lcm-fails.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace lcm_fails_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'lcm-fails.stan', line 6, column 2 to column 16)",
+                                                      " (in 'lcm-fails.stan', line 9, column 2 to column 22)",
+                                                      " (in 'lcm-fails.stan', line 2, column 2 to column 17)",
+                                                      " (in 'lcm-fails.stan', line 3, column 2 to column 12)"};
+
+
+
+class lcm_fails_model : public model_base_crtp<lcm_fails_model> {
+
+ private:
+  int pos__;
+  int J;
+  std::vector<double> y;
+ 
+ public:
+  ~lcm_fails_model() { }
+  
+  std::string model_name() const { return "lcm_fails_model"; }
+  
+  lcm_fails_model(stan::io::var_context& context__,
+                  unsigned int random_seed__ = 0,
+                  std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "lcm_fails_model_namespace::lcm_fails_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","J","int",
+          context__.to_vec());
+      J = std::numeric_limits<int>::min();
+      
+      current_statement__ = 3;
+      J = context__.vals_i("J")[(1 - 1)];
+      current_statement__ = 4;
+      validate_non_negative_index("y", "J", J);
+      context__.validate_dims("data initialization","y","double",
+          context__.to_vec(J));
+      y = std::vector<double>(J, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 4;
+      assign(y, nil_index_list(), context__.vals_r("y"),
+        "assigning variable y");
+      current_statement__ = 3;
+      current_statement__ = 3;
+      check_greater_or_equal(function__, "J", J, 0);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      current_statement__ = 1;
+      validate_non_negative_index("theta", "J", J);
+      num_params_r__ += J;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "lcm_fails_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym10__;
+      int lcm_sym9__;
+      current_statement__ = 1;
+      validate_non_negative_index("theta", "J", J);
+      std::vector<local_scalar_t__> theta;
+      theta = std::vector<local_scalar_t__>(J, DUMMY_VAR__);
+      
+      current_statement__ = 1;
+      if (logical_gte(J, 1)) {
+        current_statement__ = 1;
+        assign(theta, cons_list(index_uni(1), nil_index_list()),
+          in__.scalar(), "assigning variable theta");
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          current_statement__ = 1;
+          assign(theta, cons_list(index_uni(sym1__), nil_index_list()),
+            in__.scalar(), "assigning variable theta");}
+      } 
+      {
+        current_statement__ = 2;
+        lp_accum__.add(normal_log<propto__>(y, theta, 1));
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "lcm_fails_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym8__;
+      double lcm_sym7__;
+      int lcm_sym6__;
+      int lcm_sym5__;
+      int lcm_sym4__;
+      current_statement__ = 1;
+      validate_non_negative_index("theta", "J", J);
+      std::vector<double> theta;
+      theta = std::vector<double>(J, std::numeric_limits<double>::quiet_NaN());
+      
+      lcm_sym4__ = logical_gte(J, 1);
+      if (lcm_sym4__) {
+        current_statement__ = 1;
+        assign(theta, cons_list(index_uni(1), nil_index_list()),
+          in__.scalar(), "assigning variable theta");
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          current_statement__ = 1;
+          assign(theta, cons_list(index_uni(sym1__), nil_index_list()),
+            in__.scalar(), "assigning variable theta");}
+      } 
+      if (lcm_sym4__) {
+        vars__.push_back(
+          rvalue(theta, cons_list(index_uni(1), nil_index_list()), "theta"));
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          vars__.push_back(theta[(sym1__ - 1)]);}
+      } 
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym3__;
+      double lcm_sym2__;
+      int lcm_sym1__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      current_statement__ = 1;
+      validate_non_negative_index("theta", "J", J);
+      std::vector<double> theta;
+      theta = std::vector<double>(J, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 1;
+      assign(theta, nil_index_list(), context__.vals_r("theta"),
+        "assigning variable theta");
+      if (logical_gte(J, 1)) {
+        vars__.push_back(
+          rvalue(theta, cons_list(index_uni(1), nil_index_list()), "theta"));
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          vars__.push_back(theta[(sym1__ - 1)]);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("theta");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dims__.push_back(J);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    for (int sym11__ = 1; sym11__ <= J; ++sym11__) {
+      {
+        param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym11__));
+      }}
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    for (int sym11__ = 1; sym11__ <= J; ++sym11__) {
+      {
+        param_names__.push_back(std::string() + "theta" + '.' + std::to_string(sym11__));
+      }}
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << J << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"theta\",\"type\":{\"name\":\"array\",\"length\":" << J << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef lcm_fails_model_namespace::lcm_fails_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp lcm-fails2.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace lcm_fails2_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'lcm-fails2.stan', line 69, column 2 to column 33)",
+                                                      " (in 'lcm-fails2.stan', line 70, column 2 to column 31)",
+                                                      " (in 'lcm-fails2.stan', line 74, column 2 to column 51)",
+                                                      " (in 'lcm-fails2.stan', line 75, column 2 to column 49)",
+                                                      " (in 'lcm-fails2.stan', line 76, column 2 to column 49)",
+                                                      " (in 'lcm-fails2.stan', line 81, column 6 to column 20)",
+                                                      " (in 'lcm-fails2.stan', line 82, column 6 to column 18)",
+                                                      " (in 'lcm-fails2.stan', line 80, column 32 to line 83, column 5)",
+                                                      " (in 'lcm-fails2.stan', line 85, column 6 to column 27)",
+                                                      " (in 'lcm-fails2.stan', line 86, column 6 to column 23)",
+                                                      " (in 'lcm-fails2.stan', line 84, column 38 to line 87, column 5)",
+                                                      " (in 'lcm-fails2.stan', line 84, column 4 to line 87, column 5)",
+                                                      " (in 'lcm-fails2.stan', line 79, column 20 to line 88, column 3)",
+                                                      " (in 'lcm-fails2.stan', line 26, column 4 to column 34)",
+                                                      " (in 'lcm-fails2.stan', line 29, column 6 to column 32)",
+                                                      " (in 'lcm-fails2.stan', line 32, column 8 to column 37)",
+                                                      " (in 'lcm-fails2.stan', line 33, column 8 to column 32)",
+                                                      " (in 'lcm-fails2.stan', line 41, column 8 to line 42, column 83)",
+                                                      " (in 'lcm-fails2.stan', line 30, column 37 to line 43, column 7)",
+                                                      " (in 'lcm-fails2.stan', line 28, column 22 to line 44, column 5)",
+                                                      " (in 'lcm-fails2.stan', line 25, column 47 to line 46, column 3)",
+                                                      " (in 'lcm-fails2.stan', line 103, column 8 to column 37)",
+                                                      " (in 'lcm-fails2.stan', line 104, column 8 to column 41)",
+                                                      " (in 'lcm-fails2.stan', line 102, column 40 to line 105, column 7)",
+                                                      " (in 'lcm-fails2.stan', line 106, column 6 to column 37)",
+                                                      " (in 'lcm-fails2.stan', line 101, column 22 to line 107, column 5)",
+                                                      " (in 'lcm-fails2.stan', line 100, column 20 to line 108, column 3)",
+                                                      " (in 'lcm-fails2.stan', line 100, column 2 to line 108, column 3)",
+                                                      " (in 'lcm-fails2.stan', line 50, column 2 to column 20)",
+                                                      " (in 'lcm-fails2.stan', line 51, column 2 to column 27)",
+                                                      " (in 'lcm-fails2.stan', line 52, column 2 to column 44)",
+                                                      " (in 'lcm-fails2.stan', line 56, column 2 to column 38)",
+                                                      " (in 'lcm-fails2.stan', line 58, column 2 to column 45)",
+                                                      " (in 'lcm-fails2.stan', line 59, column 2 to column 44)",
+                                                      " (in 'lcm-fails2.stan', line 8, column 8 to column 17)",
+                                                      " (in 'lcm-fails2.stan', line 7, column 6 to line 8, column 17)",
+                                                      " (in 'lcm-fails2.stan', line 5, column 31 to line 10, column 3)",
+                                                      " (in 'lcm-fails2.stan', line 63, column 4 to column 35)",
+                                                      " (in 'lcm-fails2.stan', line 62, column 2 to line 63, column 35)",
+                                                      " (in 'lcm-fails2.stan', line 15, column 6 to column 32)",
+                                                      " (in 'lcm-fails2.stan', line 19, column 8 to column 17)",
+                                                      " (in 'lcm-fails2.stan', line 18, column 6 to line 19, column 17)",
+                                                      " (in 'lcm-fails2.stan', line 13, column 37 to line 20, column 5)",
+                                                      " (in 'lcm-fails2.stan', line 12, column 30 to line 22, column 3)",
+                                                      " (in 'lcm-fails2.stan', line 65, column 4 to column 33)",
+                                                      " (in 'lcm-fails2.stan', line 64, column 2 to line 65, column 33)",
+                                                      " (in 'lcm-fails2.stan', line 9, column 4 to column 13)",
+                                                      " (in 'lcm-fails2.stan', line 21, column 4 to column 13)",
+                                                      " (in 'lcm-fails2.stan', line 30, column 6 to line 43, column 7)",
+                                                      " (in 'lcm-fails2.stan', line 28, column 4 to line 44, column 5)",
+                                                      " (in 'lcm-fails2.stan', line 45, column 4 to column 15)"};
+
+
+int
+first_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym29__;
+    int lcm_sym28__;
+    int lcm_sym27__;
+    int lcm_sym26__;
+    {
+      lcm_sym27__ = size(y_i);
+      if (logical_gte(lcm_sym27__, 1)) {
+        current_statement__ = 36;
+        if (rvalue(y_i, cons_list(index_uni(1), nil_index_list()), "y_i")) {
+          current_statement__ = 35;
+          return 1;
+        } 
+        for (int k = 2; k <= lcm_sym27__; ++k) {
+          current_statement__ = 36;
+          if (rvalue(y_i, cons_list(index_uni(k), nil_index_list()), "y_i")) {
+            current_statement__ = 35;
+            return k;
+          } }
+      } 
+      current_statement__ = 47;
+      return 0;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct first_capture_functor__ {
+int
+operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+{
+return first_capture(y_i, pstream__);
+}
+};
+
+int
+last_capture(const std::vector<int>& y_i, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym35__;
+    int lcm_sym34__;
+    int lcm_sym33__;
+    int lcm_sym32__;
+    int lcm_sym31__;
+    int lcm_sym30__;
+    {
+      lcm_sym33__ = (size(y_i) - 1);
+      if (logical_gte(lcm_sym33__, 0)) {
+        int k;
+        k = std::numeric_limits<int>::min();
+        
+        lcm_sym32__ = (size(y_i) - 0);
+        current_statement__ = 42;
+        if (y_i[(lcm_sym32__ - 1)]) {
+          current_statement__ = 41;
+          return lcm_sym32__;
+        } 
+        for (int k_rev = 1; k_rev <= lcm_sym33__; ++k_rev) {
+          int k;
+          k = std::numeric_limits<int>::min();
+          
+          lcm_sym31__ = (size(y_i) - k_rev);
+          current_statement__ = 42;
+          if (y_i[(lcm_sym31__ - 1)]) {
+            current_statement__ = 41;
+            return lcm_sym31__;
+          } }
+      } 
+      current_statement__ = 48;
+      return 0;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct last_capture_functor__ {
+int
+operator()(const std::vector<int>& y_i, std::ostream* pstream__)  const 
+{
+return last_capture(y_i, pstream__);
+}
+};
+
+template <typename T2__, typename T3__>
+Eigen::Matrix<stan::promote_args_t<T2__,
+T3__>, -1, -1>
+prob_uncaptured(const int& nind, const int& n_occasions,
+                const Eigen::Matrix<T2__, -1, -1>& p,
+                const Eigen::Matrix<T3__, -1, -1>& phi,
+                std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<T2__, T3__>;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    double lcm_sym45__;
+    double lcm_sym44__;
+    double lcm_sym43__;
+    double lcm_sym42__;
+    int lcm_sym41__;
+    int lcm_sym40__;
+    int lcm_sym39__;
+    int lcm_sym38__;
+    int lcm_sym37__;
+    int lcm_sym36__;
+    {
+      current_statement__ = 14;
+      validate_non_negative_index("chi", "nind", nind);
+      current_statement__ = 14;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      current_statement__ = 50;
+      if (logical_gte(nind, 1)) {
+        current_statement__ = 15;
+        assign(chi,
+          cons_list(index_uni(1),
+            cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+          "assigning variable chi");
+        lcm_sym39__ = (n_occasions - 1);
+        lcm_sym37__ = logical_gte(lcm_sym39__, 1);
+        if (lcm_sym37__) {
+          int t_curr;
+          t_curr = std::numeric_limits<int>::min();
+          
+          int t_next;
+          t_next = std::numeric_limits<int>::min();
+          
+          lcm_sym41__ = (lcm_sym39__ + 1);
+          current_statement__ = 18;
+          assign(chi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym39__), nil_index_list())),
+            stan::math::fma(
+              (rvalue(phi,
+                 cons_list(index_uni(1),
+                   cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                 "phi") *
+                (1 -
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((lcm_sym41__ - 1)),
+                        nil_index_list())), "p"))),
+              rvalue(chi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(lcm_sym41__), nil_index_list())),
+                "chi"),
+              (1 -
+                rvalue(phi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                  "phi"))), "assigning variable chi");
+          for (int t = 2; t <= lcm_sym39__; ++t) {
+            int t_curr;
+            t_curr = std::numeric_limits<int>::min();
+            
+            lcm_sym38__ = (n_occasions - t);
+            int t_next;
+            t_next = std::numeric_limits<int>::min();
+            
+            lcm_sym40__ = (lcm_sym38__ + 1);
+            current_statement__ = 18;
+            assign(chi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(lcm_sym38__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(1),
+                     cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((lcm_sym40__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(chi,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym40__), nil_index_list())),
+                  "chi"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                    "phi"))), "assigning variable chi");}
+        } 
+        for (int i = 2; i <= nind; ++i) {
+          current_statement__ = 15;
+          assign(chi,
+            cons_list(index_uni(i),
+              cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+            "assigning variable chi");
+          current_statement__ = 49;
+          if (lcm_sym37__) {
+            int t_curr;
+            t_curr = std::numeric_limits<int>::min();
+            
+            int t_next;
+            t_next = std::numeric_limits<int>::min();
+            
+            lcm_sym41__ = (lcm_sym39__ + 1);
+            current_statement__ = 18;
+            assign(chi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym39__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(i),
+                     cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((lcm_sym41__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(chi,
+                  cons_list(index_uni(i),
+                    cons_list(index_uni(lcm_sym41__), nil_index_list())),
+                  "chi"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym39__), nil_index_list())),
+                    "phi"))), "assigning variable chi");
+            for (int t = 2; t <= lcm_sym39__; ++t) {
+              int t_curr;
+              t_curr = std::numeric_limits<int>::min();
+              
+              lcm_sym38__ = (n_occasions - t);
+              int t_next;
+              t_next = std::numeric_limits<int>::min();
+              
+              lcm_sym40__ = (lcm_sym38__ + 1);
+              current_statement__ = 18;
+              assign(chi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(i),
+                       cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((lcm_sym40__ - 1)),
+                            nil_index_list())), "p"))),
+                  rvalue(chi,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym40__), nil_index_list())),
+                    "chi"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym38__), nil_index_list())),
+                      "phi"))), "assigning variable chi");}
+          } }
+      } 
+      current_statement__ = 51;
+      return chi;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct prob_uncaptured_functor__ {
+template <typename T2__, typename T3__>
+Eigen::Matrix<stan::promote_args_t<T2__,
+T3__>, -1, -1>
+operator()(const int& nind, const int& n_occasions,
+           const Eigen::Matrix<T2__, -1, -1>& p,
+           const Eigen::Matrix<T3__, -1, -1>& phi, std::ostream* pstream__)  const 
+{
+return prob_uncaptured(nind, n_occasions, p, phi, pstream__);
+}
+};
+
+class lcm_fails2_model : public model_base_crtp<lcm_fails2_model> {
+
+ private:
+  int lcm_sym138__;
+  int lcm_sym137__;
+  int lcm_sym136__;
+  int lcm_sym135__;
+  int lcm_sym134__;
+  int lcm_sym133__;
+  int lcm_sym132__;
+  int lcm_sym131__;
+  int lcm_sym130__;
+  int lcm_sym129__;
+  int lcm_sym128__;
+  int lcm_sym127__;
+  int lcm_sym126__;
+  int lcm_sym125__;
+  int lcm_sym124__;
+  int lcm_sym123__;
+  int lcm_sym122__;
+  int lcm_sym121__;
+  int lcm_sym120__;
+  int lcm_sym119__;
+  int lcm_sym118__;
+  int lcm_sym117__;
+  int lcm_sym116__;
+  int lcm_sym115__;
+  int pos__;
+  int nind;
+  int n_occasions;
+  std::vector<std::vector<int>> y;
+  int n_occ_minus_1;
+  std::vector<int> first;
+  std::vector<int> last;
+ 
+ public:
+  ~lcm_fails2_model() { }
+  
+  std::string model_name() const { return "lcm_fails2_model"; }
+  
+  lcm_fails2_model(stan::io::var_context& context__,
+                   unsigned int random_seed__ = 0,
+                   std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "lcm_fails2_model_namespace::lcm_fails2_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","nind","int",
+          context__.to_vec());
+      nind = std::numeric_limits<int>::min();
+      
+      current_statement__ = 29;
+      nind = context__.vals_i("nind")[(1 - 1)];
+      context__.validate_dims("data initialization","n_occasions","int",
+          context__.to_vec());
+      n_occasions = std::numeric_limits<int>::min();
+      
+      current_statement__ = 30;
+      n_occasions = context__.vals_i("n_occasions")[(1 - 1)];
+      current_statement__ = 31;
+      validate_non_negative_index("y", "nind", nind);
+      current_statement__ = 31;
+      validate_non_negative_index("y", "n_occasions", n_occasions);
+      context__.validate_dims("data initialization","y","int",
+          context__.to_vec(nind, n_occasions));
+      y = std::vector<std::vector<int>>(nind, std::vector<int>(n_occasions, std::numeric_limits<int>::min()));
+      
+      {
+        std::vector<int> y_flat__;
+        current_statement__ = 31;
+        assign(y_flat__, nil_index_list(), context__.vals_i("y"),
+          "assigning variable y_flat__");
+        current_statement__ = 31;
+        pos__ = 1;
+        lcm_sym115__ = logical_gte(n_occasions, 1);
+        if (lcm_sym115__) {
+          {
+            lcm_sym116__ = logical_gte(nind, 1);
+            if (lcm_sym116__) {
+              current_statement__ = 31;
+              assign(y,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(1), nil_index_list())),
+                rvalue(y_flat__, cons_list(index_uni(1), nil_index_list()),
+                  "y_flat__"), "assigning variable y");
+              current_statement__ = 31;
+              pos__ = 2;
+              for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+                current_statement__ = 31;
+                assign(y,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(1), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 31;
+                pos__ = (pos__ + 1);}
+            } 
+            for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+              current_statement__ = 31;
+              if (lcm_sym116__) {
+                current_statement__ = 31;
+                assign(y,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 31;
+                pos__ = (pos__ + 1);
+                for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+                  current_statement__ = 31;
+                  assign(y,
+                    cons_list(index_uni(sym2__),
+                      cons_list(index_uni(sym1__), nil_index_list())),
+                    y_flat__[(pos__ - 1)], "assigning variable y");
+                  current_statement__ = 31;
+                  pos__ = (pos__ + 1);}
+              } }
+          }
+        } else {
+          lcm_sym116__ = logical_gte(nind, 1);
+        }
+      }
+      n_occ_minus_1 = std::numeric_limits<int>::min();
+      
+      current_statement__ = 32;
+      n_occ_minus_1 = (n_occasions - 1);
+      current_statement__ = 33;
+      validate_non_negative_index("first", "nind", nind);
+      first = std::vector<int>(nind, std::numeric_limits<int>::min());
+      
+      current_statement__ = 34;
+      validate_non_negative_index("last", "nind", nind);
+      last = std::vector<int>(nind, std::numeric_limits<int>::min());
+      
+      current_statement__ = 39;
+      if (lcm_sym116__) {
+        int inline_sym17__;
+        int inline_sym19__;
+        inline_sym19__ = std::numeric_limits<int>::min();
+        
+        inline_sym19__ = 0;
+        for (int inline_sym20__ = 1; inline_sym20__ <= 1; ++inline_sym20__) {
+          lcm_sym124__ = size(
+                           rvalue(y,
+                             cons_list(index_uni(1), nil_index_list()), "y"));
+          for (int inline_sym18__ = 1; inline_sym18__ <= lcm_sym124__;
+               ++inline_sym18__) {
+            current_statement__ = 36;
+            if (rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")[
+                (inline_sym18__ - 1)]) {
+              inline_sym19__ = 1;
+              inline_sym17__ = inline_sym18__;
+              break;
+            } }
+          if (inline_sym19__) {
+            break;
+          } 
+          inline_sym19__ = 1;
+          inline_sym17__ = 0;
+          break;}
+        assign(first, cons_list(index_uni(1), nil_index_list()),
+          inline_sym17__, "assigning variable first");
+        for (int i = 2; i <= nind; ++i) {
+          int inline_sym17__;
+          int inline_sym19__;
+          inline_sym19__ = std::numeric_limits<int>::min();
+          
+          inline_sym19__ = 0;
+          for (int inline_sym20__ = 1; inline_sym20__ <= 1; ++inline_sym20__) {
+            lcm_sym123__ = size(
+                             rvalue(y,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "y"));
+            for (int inline_sym18__ = 1; inline_sym18__ <= lcm_sym123__;
+                 ++inline_sym18__) {
+              current_statement__ = 36;
+              if (rvalue(y, cons_list(index_uni(i), nil_index_list()), "y")[
+                  (inline_sym18__ - 1)]) {
+                inline_sym19__ = 1;
+                inline_sym17__ = inline_sym18__;
+                break;
+              } }
+            if (inline_sym19__) {
+              break;
+            } 
+            inline_sym19__ = 1;
+            inline_sym17__ = 0;
+            break;}
+          assign(first, cons_list(index_uni(i), nil_index_list()),
+            inline_sym17__, "assigning variable first");}
+      } 
+      current_statement__ = 46;
+      if (lcm_sym116__) {
+        int inline_sym21__;
+        int inline_sym24__;
+        inline_sym24__ = std::numeric_limits<int>::min();
+        
+        inline_sym24__ = 0;
+        for (int inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) {
+          lcm_sym124__ = size(
+                           rvalue(y,
+                             cons_list(index_uni(1), nil_index_list()), "y"));
+          lcm_sym121__ = (lcm_sym124__ - 1);
+          for (int inline_sym23__ = 0; inline_sym23__ <= lcm_sym121__;
+               ++inline_sym23__) {
+            int inline_sym22__;
+            inline_sym22__ = std::numeric_limits<int>::min();
+            
+            lcm_sym120__ = (lcm_sym124__ - inline_sym23__);
+            inline_sym22__ = lcm_sym120__;
+            current_statement__ = 42;
+            if (rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")[
+                (lcm_sym120__ - 1)]) {
+              inline_sym24__ = 1;
+              inline_sym21__ = lcm_sym120__;
+              break;
+            } }
+          if (inline_sym24__) {
+            break;
+          } 
+          inline_sym24__ = 1;
+          inline_sym21__ = 0;
+          break;}
+        assign(last, cons_list(index_uni(1), nil_index_list()),
+          inline_sym21__, "assigning variable last");
+        for (int i = 2; i <= nind; ++i) {
+          int inline_sym21__;
+          int inline_sym24__;
+          inline_sym24__ = std::numeric_limits<int>::min();
+          
+          inline_sym24__ = 0;
+          for (int inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) {
+            lcm_sym123__ = size(
+                             rvalue(y,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "y"));
+            lcm_sym119__ = (lcm_sym123__ - 1);
+            for (int inline_sym23__ = 0; inline_sym23__ <= lcm_sym119__;
+                 ++inline_sym23__) {
+              int inline_sym22__;
+              inline_sym22__ = std::numeric_limits<int>::min();
+              
+              lcm_sym118__ = (lcm_sym123__ - inline_sym23__);
+              inline_sym22__ = lcm_sym118__;
+              current_statement__ = 42;
+              if (rvalue(y, cons_list(index_uni(i), nil_index_list()), "y")[
+                  (lcm_sym118__ - 1)]) {
+                inline_sym24__ = 1;
+                inline_sym21__ = lcm_sym118__;
+                break;
+              } }
+            if (inline_sym24__) {
+              break;
+            } 
+            inline_sym24__ = 1;
+            inline_sym21__ = 0;
+            break;}
+          assign(last, cons_list(index_uni(i), nil_index_list()),
+            inline_sym21__, "assigning variable last");}
+      } 
+      current_statement__ = 29;
+      current_statement__ = 29;
+      check_greater_or_equal(function__, "nind", nind, 0);
+      current_statement__ = 30;
+      current_statement__ = 30;
+      check_greater_or_equal(function__, "n_occasions", n_occasions, 2);
+      current_statement__ = 31;
+      if (lcm_sym116__) {
+        current_statement__ = 31;
+        if (lcm_sym115__) {
+          current_statement__ = 31;
+          current_statement__ = 31;
+          check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                 rvalue(y,
+                                   cons_list(index_uni(1),
+                                     cons_list(index_uni(1),
+                                       nil_index_list())), "y"), 0);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 31;
+            current_statement__ = 31;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(1),
+                                       cons_list(index_uni(sym2__),
+                                         nil_index_list())), "y"), 0);}
+        } 
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 31;
+          if (lcm_sym115__) {
+            current_statement__ = 31;
+            current_statement__ = 31;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(sym1__),
+                                       cons_list(index_uni(1),
+                                         nil_index_list())), "y"), 0);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 31;
+              current_statement__ = 31;
+              check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                     y[(sym1__ - 1)][(sym2__ - 1)], 0);}
+          } }
+      } 
+      current_statement__ = 31;
+      if (lcm_sym116__) {
+        current_statement__ = 31;
+        if (lcm_sym115__) {
+          current_statement__ = 31;
+          current_statement__ = 31;
+          check_less_or_equal(function__, "y[sym1__, sym2__]",
+                              rvalue(y,
+                                cons_list(index_uni(1),
+                                  cons_list(index_uni(1), nil_index_list())),
+                                "y"), 1);
+          for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+            current_statement__ = 31;
+            current_statement__ = 31;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(1),
+                                    cons_list(index_uni(sym2__),
+                                      nil_index_list())), "y"), 1);}
+        } 
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 31;
+          if (lcm_sym115__) {
+            current_statement__ = 31;
+            current_statement__ = 31;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(sym1__),
+                                    cons_list(index_uni(1), nil_index_list())),
+                                  "y"), 1);
+            for (int sym2__ = 2; sym2__ <= n_occasions; ++sym2__) {
+              current_statement__ = 31;
+              current_statement__ = 31;
+              check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                  y[(sym1__ - 1)][(sym2__ - 1)], 1);}
+          } }
+      } 
+      current_statement__ = 33;
+      if (lcm_sym116__) {
+        current_statement__ = 33;
+        current_statement__ = 33;
+        check_greater_or_equal(function__, "first[sym1__]",
+                               rvalue(first,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "first"), 0);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 33;
+          current_statement__ = 33;
+          check_greater_or_equal(function__, "first[sym1__]",
+                                 first[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 33;
+      if (lcm_sym116__) {
+        current_statement__ = 33;
+        current_statement__ = 33;
+        check_less_or_equal(function__, "first[sym1__]",
+                            rvalue(first,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "first"), n_occasions);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 33;
+          current_statement__ = 33;
+          check_less_or_equal(function__, "first[sym1__]",
+                              first[(sym1__ - 1)], n_occasions);}
+      } 
+      current_statement__ = 34;
+      if (lcm_sym116__) {
+        current_statement__ = 34;
+        current_statement__ = 34;
+        check_greater_or_equal(function__, "last[sym1__]",
+                               rvalue(last,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "last"), 0);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 34;
+          current_statement__ = 34;
+          check_greater_or_equal(function__, "last[sym1__]",
+                                 last[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 34;
+      if (lcm_sym116__) {
+        current_statement__ = 34;
+        current_statement__ = 34;
+        check_less_or_equal(function__, "last[sym1__]",
+                            rvalue(last,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "last"), n_occasions);
+        for (int sym1__ = 2; sym1__ <= nind; ++sym1__) {
+          current_statement__ = 34;
+          current_statement__ = 34;
+          check_less_or_equal(function__, "last[sym1__]", last[(sym1__ - 1)],
+                              n_occasions);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "lcm_fails2_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      int lcm_sym114__;
+      int lcm_sym113__;
+      int lcm_sym112__;
+      int lcm_sym111__;
+      double lcm_sym110__;
+      double lcm_sym109__;
+      double lcm_sym108__;
+      double lcm_sym107__;
+      double lcm_sym106__;
+      double lcm_sym105__;
+      double lcm_sym104__;
+      double lcm_sym103__;
+      double lcm_sym102__;
+      double lcm_sym101__;
+      double lcm_sym100__;
+      double lcm_sym99__;
+      int lcm_sym98__;
+      int lcm_sym97__;
+      int lcm_sym96__;
+      int lcm_sym95__;
+      int lcm_sym94__;
+      int lcm_sym93__;
+      int lcm_sym92__;
+      int lcm_sym91__;
+      int lcm_sym90__;
+      int lcm_sym89__;
+      int lcm_sym88__;
+      int lcm_sym87__;
+      int lcm_sym86__;
+      int lcm_sym85__;
+      int lcm_sym84__;
+      int lcm_sym83__;
+      int lcm_sym82__;
+      int lcm_sym81__;
+      int lcm_sym80__;
+      int lcm_sym79__;
+      local_scalar_t__ mean_phi;
+      mean_phi = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      mean_phi = in__.scalar();
+      current_statement__ = 1;
+      if (jacobian__) {
+        current_statement__ = 1;
+        mean_phi = stan::math::lub_constrain(mean_phi, 0, 1, lp__);
+      } else {
+        current_statement__ = 1;
+        mean_phi = stan::math::lub_constrain(mean_phi, 0, 1);
+      }
+      local_scalar_t__ mean_p;
+      mean_p = DUMMY_VAR__;
+      
+      current_statement__ = 2;
+      mean_p = in__.scalar();
+      current_statement__ = 2;
+      if (jacobian__) {
+        current_statement__ = 2;
+        mean_p = stan::math::lub_constrain(mean_p, 0, 1, lp__);
+      } else {
+        current_statement__ = 2;
+        mean_p = stan::math::lub_constrain(mean_p, 0, 1);
+      }
+      current_statement__ = 3;
+      validate_non_negative_index("phi", "nind", nind);
+      lcm_sym90__ = (n_occasions - 1);
+      validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym90__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> phi;
+      phi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, lcm_sym90__);
+      stan::math::fill(phi, DUMMY_VAR__);
+      
+      current_statement__ = 4;
+      validate_non_negative_index("p", "nind", nind);
+      current_statement__ = 4;
+      validate_non_negative_index("p", "n_occ_minus_1", lcm_sym90__);
+      Eigen::Matrix<local_scalar_t__, -1, -1> p;
+      p = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, lcm_sym90__);
+      stan::math::fill(p, DUMMY_VAR__);
+      
+      current_statement__ = 5;
+      validate_non_negative_index("chi", "nind", nind);
+      current_statement__ = 5;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      lcm_sym79__ = logical_gte(nind, 1);
+      if (lcm_sym79__) {
+        lcm_sym112__ = rvalue(first,
+                         cons_list(index_uni(1), nil_index_list()), "first");
+        lcm_sym92__ = (lcm_sym112__ - 1);
+        if (logical_gte(lcm_sym92__, 1)) {
+          current_statement__ = 6;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable phi");
+          current_statement__ = 7;
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable p");
+          for (int t = 2; t <= lcm_sym92__; ++t) {
+            current_statement__ = 6;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 7;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable p");}
+        } 
+        current_statement__ = 12;
+        if (logical_gte(lcm_sym90__, lcm_sym112__)) {
+          current_statement__ = 9;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym112__), nil_index_list())),
+            mean_phi, "assigning variable phi");
+          lcm_sym98__ = (lcm_sym112__ + 1);
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym112__), nil_index_list())), mean_p,
+            "assigning variable p");
+          for (int t = lcm_sym98__; t <= lcm_sym90__; ++t) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), mean_phi,
+              "assigning variable phi");
+            current_statement__ = 10;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), mean_p,
+              "assigning variable p");}
+        } 
+        for (int i = 2; i <= nind; ++i) {
+          lcm_sym111__ = rvalue(first,
+                           cons_list(index_uni(i), nil_index_list()),
+                           "first");
+          lcm_sym91__ = (lcm_sym111__ - 1);
+          if (logical_gte(lcm_sym91__, 1)) {
+            current_statement__ = 6;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 7;
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable p");
+            for (int t = 2; t <= lcm_sym91__; ++t) {
+              current_statement__ = 6;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable phi");
+              current_statement__ = 7;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable p");}
+          } 
+          current_statement__ = 12;
+          if (logical_gte(lcm_sym90__, lcm_sym111__)) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym111__), nil_index_list())),
+              mean_phi, "assigning variable phi");
+            lcm_sym97__ = (lcm_sym111__ + 1);
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym111__), nil_index_list())),
+              mean_p, "assigning variable p");
+            for (int t = lcm_sym97__; t <= lcm_sym90__; ++t) {
+              current_statement__ = 9;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), mean_phi,
+                "assigning variable phi");
+              current_statement__ = 10;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), mean_p,
+                "assigning variable p");}
+          } }
+      } 
+      Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym9__;
+      int inline_sym15__;
+      inline_sym15__ = std::numeric_limits<int>::min();
+      
+      inline_sym15__ = 0;
+      for (int inline_sym16__ = 1; inline_sym16__ <= 1; ++inline_sym16__) {
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "nind", nind);
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "n_occasions", n_occasions);
+        Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym10__;
+        inline_sym10__ = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+        stan::math::fill(inline_sym10__, DUMMY_VAR__);
+        
+        for (int inline_sym14__ = 1; inline_sym14__ <= nind; ++inline_sym14__) {
+          current_statement__ = 15;
+          assign(inline_sym10__,
+            cons_list(index_uni(inline_sym14__),
+              cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+            "assigning variable inline_sym10__");
+          if (logical_gte(lcm_sym90__, 1)) {
+            int inline_sym11__;
+            inline_sym11__ = std::numeric_limits<int>::min();
+            
+            int inline_sym12__;
+            inline_sym12__ = std::numeric_limits<int>::min();
+            
+            lcm_sym94__ = (lcm_sym90__ + 1);
+            current_statement__ = 18;
+            assign(inline_sym10__,
+              cons_list(index_uni(inline_sym14__),
+                cons_list(index_uni(lcm_sym90__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(inline_sym14__),
+                     cons_list(index_uni(lcm_sym90__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(inline_sym14__),
+                        cons_list(index_uni((lcm_sym94__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(inline_sym10__,
+                  cons_list(index_uni(inline_sym14__),
+                    cons_list(index_uni(lcm_sym94__), nil_index_list())),
+                  "inline_sym10__"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(inline_sym14__),
+                      cons_list(index_uni(lcm_sym90__), nil_index_list())),
+                    "phi"))), "assigning variable inline_sym10__");
+            for (int inline_sym13__ = 2; inline_sym13__ <= lcm_sym90__;
+                 ++inline_sym13__) {
+              int inline_sym11__;
+              inline_sym11__ = std::numeric_limits<int>::min();
+              
+              lcm_sym89__ = (n_occasions - inline_sym13__);
+              int inline_sym12__;
+              inline_sym12__ = std::numeric_limits<int>::min();
+              
+              lcm_sym93__ = (lcm_sym89__ + 1);
+              current_statement__ = 18;
+              assign(inline_sym10__,
+                cons_list(index_uni(inline_sym14__),
+                  cons_list(index_uni(lcm_sym89__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(inline_sym14__),
+                       cons_list(index_uni(lcm_sym89__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(inline_sym14__),
+                          cons_list(index_uni((lcm_sym93__ - 1)),
+                            nil_index_list())), "p"))),
+                  rvalue(inline_sym10__,
+                    cons_list(index_uni(inline_sym14__),
+                      cons_list(index_uni(lcm_sym93__), nil_index_list())),
+                    "inline_sym10__"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(inline_sym14__),
+                        cons_list(index_uni(lcm_sym89__), nil_index_list())),
+                      "phi"))), "assigning variable inline_sym10__");}
+          } 
+          if (inline_sym15__) {
+            break;
+          } }
+        if (inline_sym15__) {
+          break;
+        } 
+        inline_sym15__ = 1;
+        assign(inline_sym9__, nil_index_list(), inline_sym10__,
+          "assigning variable inline_sym9__");
+        break;}
+      assign(chi, nil_index_list(), inline_sym9__, "assigning variable chi");
+      current_statement__ = 3;
+      current_statement__ = 3;
+      check_greater_or_equal(function__, "phi", phi, 0);
+      current_statement__ = 3;
+      current_statement__ = 3;
+      check_less_or_equal(function__, "phi", phi, 1);
+      current_statement__ = 4;
+      current_statement__ = 4;
+      check_greater_or_equal(function__, "p", p, 0);
+      current_statement__ = 4;
+      current_statement__ = 4;
+      check_less_or_equal(function__, "p", p, 1);
+      current_statement__ = 5;
+      current_statement__ = 5;
+      check_greater_or_equal(function__, "chi", inline_sym9__, 0);
+      current_statement__ = 5;
+      current_statement__ = 5;
+      check_less_or_equal(function__, "chi", inline_sym9__, 1);
+      {
+        current_statement__ = 28;
+        if (lcm_sym79__) {
+          lcm_sym112__ = rvalue(first,
+                           cons_list(index_uni(1), nil_index_list()),
+                           "first");
+          if (logical_gt(lcm_sym112__, 0)) {
+            lcm_sym114__ = rvalue(last,
+                             cons_list(index_uni(1), nil_index_list()),
+                             "last");
+            lcm_sym98__ = (lcm_sym112__ + 1);
+            if (logical_gte(lcm_sym114__, lcm_sym98__)) {
+              current_statement__ = 22;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(phi,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((lcm_sym98__ - 1)),
+                        nil_index_list())), "phi")));
+              lcm_sym96__ = (lcm_sym98__ + 1);
+              lp_accum__.add(
+                bernoulli_log<propto__>(
+                  rvalue(y,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni(lcm_sym98__), nil_index_list())),
+                    "y"),
+                  rvalue(p,
+                    cons_list(index_uni(1),
+                      cons_list(index_uni((lcm_sym98__ - 1)),
+                        nil_index_list())), "p")));
+              for (int t = lcm_sym96__; t <= lcm_sym114__; ++t) {
+                current_statement__ = 22;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(phi,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((t - 1)), nil_index_list())),
+                      "phi")));
+                current_statement__ = 23;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(
+                    rvalue(y,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni(t), nil_index_list())), "y"),
+                    rvalue(p,
+                      cons_list(index_uni(1),
+                        cons_list(index_uni((t - 1)), nil_index_list())),
+                      "p")));}
+            } 
+            current_statement__ = 25;
+            lp_accum__.add(
+              bernoulli_log<propto__>(1,
+                rvalue(inline_sym9__,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(lcm_sym114__), nil_index_list())),
+                  "inline_sym9__")));
+          } 
+          for (int i = 2; i <= nind; ++i) {
+            lcm_sym111__ = rvalue(first,
+                             cons_list(index_uni(i), nil_index_list()),
+                             "first");
+            if (logical_gt(lcm_sym111__, 0)) {
+              lcm_sym113__ = rvalue(last,
+                               cons_list(index_uni(i), nil_index_list()),
+                               "last");
+              lcm_sym97__ = (lcm_sym111__ + 1);
+              if (logical_gte(lcm_sym113__, lcm_sym97__)) {
+                current_statement__ = 22;
+                lp_accum__.add(
+                  bernoulli_log<propto__>(1,
+                    rvalue(phi,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((lcm_sym97__ - 1)),
+                          nil_index_list())), "phi")));
+                lcm_sym95__ = (lcm_sym97__ + 1);
+                lp_accum__.add(
+                  bernoulli_log<propto__>(
+                    rvalue(y,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni(lcm_sym97__), nil_index_list())),
+                      "y"),
+                    rvalue(p,
+                      cons_list(index_uni(i),
+                        cons_list(index_uni((lcm_sym97__ - 1)),
+                          nil_index_list())), "p")));
+                for (int t = lcm_sym95__; t <= lcm_sym113__; ++t) {
+                  current_statement__ = 22;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(1,
+                      rvalue(phi,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((t - 1)), nil_index_list())),
+                        "phi")));
+                  current_statement__ = 23;
+                  lp_accum__.add(
+                    bernoulli_log<propto__>(
+                      rvalue(y,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni(t), nil_index_list())), "y"),
+                      rvalue(p,
+                        cons_list(index_uni(i),
+                          cons_list(index_uni((t - 1)), nil_index_list())),
+                        "p")));}
+              } 
+              current_statement__ = 25;
+              lp_accum__.add(
+                bernoulli_log<propto__>(1,
+                  rvalue(inline_sym9__,
+                    cons_list(index_uni(i),
+                      cons_list(index_uni(lcm_sym113__), nil_index_list())),
+                    "inline_sym9__")));
+            } }
+        } 
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "lcm_fails2_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym78__;
+      double lcm_sym77__;
+      double lcm_sym76__;
+      double lcm_sym75__;
+      double lcm_sym74__;
+      double lcm_sym73__;
+      double lcm_sym72__;
+      double lcm_sym71__;
+      double lcm_sym70__;
+      double lcm_sym69__;
+      double lcm_sym68__;
+      double lcm_sym67__;
+      int lcm_sym66__;
+      int lcm_sym65__;
+      double lcm_sym64__;
+      double lcm_sym63__;
+      int lcm_sym62__;
+      int lcm_sym61__;
+      int lcm_sym60__;
+      int lcm_sym59__;
+      int lcm_sym58__;
+      int lcm_sym57__;
+      int lcm_sym56__;
+      int lcm_sym55__;
+      int lcm_sym54__;
+      int lcm_sym53__;
+      int lcm_sym52__;
+      int lcm_sym51__;
+      int lcm_sym50__;
+      int lcm_sym49__;
+      int lcm_sym48__;
+      int lcm_sym47__;
+      int lcm_sym46__;
+      double mean_phi;
+      mean_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mean_phi = in__.scalar();
+      current_statement__ = 1;
+      mean_phi = stan::math::lub_constrain(mean_phi, 0, 1);
+      double mean_p;
+      mean_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      mean_p = in__.scalar();
+      current_statement__ = 2;
+      mean_p = stan::math::lub_constrain(mean_p, 0, 1);
+      current_statement__ = 3;
+      validate_non_negative_index("phi", "nind", nind);
+      lcm_sym54__ = (n_occasions - 1);
+      validate_non_negative_index("phi", "n_occ_minus_1", lcm_sym54__);
+      Eigen::Matrix<double, -1, -1> phi;
+      phi = Eigen::Matrix<double, -1, -1>(nind, lcm_sym54__);
+      stan::math::fill(phi, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 4;
+      validate_non_negative_index("p", "nind", nind);
+      current_statement__ = 4;
+      validate_non_negative_index("p", "n_occ_minus_1", lcm_sym54__);
+      Eigen::Matrix<double, -1, -1> p;
+      p = Eigen::Matrix<double, -1, -1>(nind, lcm_sym54__);
+      stan::math::fill(p, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 5;
+      validate_non_negative_index("chi", "nind", nind);
+      current_statement__ = 5;
+      validate_non_negative_index("chi", "n_occasions", n_occasions);
+      Eigen::Matrix<local_scalar_t__, -1, -1> chi;
+      chi = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+      stan::math::fill(chi, DUMMY_VAR__);
+      
+      vars__.push_back(mean_phi);
+      vars__.push_back(mean_p);
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      lcm_sym47__ = logical_gte(nind, 1);
+      if (lcm_sym47__) {
+        lcm_sym66__ = rvalue(first,
+                        cons_list(index_uni(1), nil_index_list()), "first");
+        lcm_sym56__ = (lcm_sym66__ - 1);
+        if (logical_gte(lcm_sym56__, 1)) {
+          current_statement__ = 6;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable phi");
+          current_statement__ = 7;
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(1), nil_index_list())), 0,
+            "assigning variable p");
+          for (int t = 2; t <= lcm_sym56__; ++t) {
+            current_statement__ = 6;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 7;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), 0,
+              "assigning variable p");}
+        } 
+        current_statement__ = 12;
+        if (logical_gte(lcm_sym54__, lcm_sym66__)) {
+          current_statement__ = 9;
+          assign(phi,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym66__), nil_index_list())), mean_phi,
+            "assigning variable phi");
+          lcm_sym62__ = (lcm_sym66__ + 1);
+          assign(p,
+            cons_list(index_uni(1),
+              cons_list(index_uni(lcm_sym66__), nil_index_list())), mean_p,
+            "assigning variable p");
+          for (int t = lcm_sym62__; t <= lcm_sym54__; ++t) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), mean_phi,
+              "assigning variable phi");
+            current_statement__ = 10;
+            assign(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(t), nil_index_list())), mean_p,
+              "assigning variable p");}
+        } 
+        for (int i = 2; i <= nind; ++i) {
+          lcm_sym65__ = rvalue(first,
+                          cons_list(index_uni(i), nil_index_list()), "first");
+          lcm_sym55__ = (lcm_sym65__ - 1);
+          if (logical_gte(lcm_sym55__, 1)) {
+            current_statement__ = 6;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable phi");
+            current_statement__ = 7;
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(1), nil_index_list())), 0,
+              "assigning variable p");
+            for (int t = 2; t <= lcm_sym55__; ++t) {
+              current_statement__ = 6;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable phi");
+              current_statement__ = 7;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), 0,
+                "assigning variable p");}
+          } 
+          current_statement__ = 12;
+          if (logical_gte(lcm_sym54__, lcm_sym65__)) {
+            current_statement__ = 9;
+            assign(phi,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym65__), nil_index_list())),
+              mean_phi, "assigning variable phi");
+            lcm_sym61__ = (lcm_sym65__ + 1);
+            assign(p,
+              cons_list(index_uni(i),
+                cons_list(index_uni(lcm_sym65__), nil_index_list())), mean_p,
+              "assigning variable p");
+            for (int t = lcm_sym61__; t <= lcm_sym54__; ++t) {
+              current_statement__ = 9;
+              assign(phi,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), mean_phi,
+                "assigning variable phi");
+              current_statement__ = 10;
+              assign(p,
+                cons_list(index_uni(i),
+                  cons_list(index_uni(t), nil_index_list())), mean_p,
+                "assigning variable p");}
+          } }
+      } 
+      Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym1__;
+      int inline_sym7__;
+      inline_sym7__ = std::numeric_limits<int>::min();
+      
+      lcm_sym48__ = logical_gte(lcm_sym54__, 1);
+      inline_sym7__ = 0;
+      for (int inline_sym8__ = 1; inline_sym8__ <= 1; ++inline_sym8__) {
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "nind", nind);
+        current_statement__ = 14;
+        validate_non_negative_index("chi", "n_occasions", n_occasions);
+        Eigen::Matrix<local_scalar_t__, -1, -1> inline_sym2__;
+        inline_sym2__ = Eigen::Matrix<local_scalar_t__, -1, -1>(nind, n_occasions);
+        stan::math::fill(inline_sym2__, DUMMY_VAR__);
+        
+        for (int inline_sym6__ = 1; inline_sym6__ <= nind; ++inline_sym6__) {
+          current_statement__ = 15;
+          assign(inline_sym2__,
+            cons_list(index_uni(inline_sym6__),
+              cons_list(index_uni(n_occasions), nil_index_list())), 1.0,
+            "assigning variable inline_sym2__");
+          if (lcm_sym48__) {
+            int inline_sym3__;
+            inline_sym3__ = std::numeric_limits<int>::min();
+            
+            int inline_sym4__;
+            inline_sym4__ = std::numeric_limits<int>::min();
+            
+            lcm_sym60__ = (lcm_sym54__ + 1);
+            current_statement__ = 18;
+            assign(inline_sym2__,
+              cons_list(index_uni(inline_sym6__),
+                cons_list(index_uni(lcm_sym54__), nil_index_list())),
+              stan::math::fma(
+                (rvalue(phi,
+                   cons_list(index_uni(inline_sym6__),
+                     cons_list(index_uni(lcm_sym54__), nil_index_list())),
+                   "phi") *
+                  (1 -
+                    rvalue(p,
+                      cons_list(index_uni(inline_sym6__),
+                        cons_list(index_uni((lcm_sym60__ - 1)),
+                          nil_index_list())), "p"))),
+                rvalue(inline_sym2__,
+                  cons_list(index_uni(inline_sym6__),
+                    cons_list(index_uni(lcm_sym60__), nil_index_list())),
+                  "inline_sym2__"),
+                (1 -
+                  rvalue(phi,
+                    cons_list(index_uni(inline_sym6__),
+                      cons_list(index_uni(lcm_sym54__), nil_index_list())),
+                    "phi"))), "assigning variable inline_sym2__");
+            for (int inline_sym5__ = 2; inline_sym5__ <= lcm_sym54__;
+                 ++inline_sym5__) {
+              int inline_sym3__;
+              inline_sym3__ = std::numeric_limits<int>::min();
+              
+              lcm_sym53__ = (n_occasions - inline_sym5__);
+              int inline_sym4__;
+              inline_sym4__ = std::numeric_limits<int>::min();
+              
+              lcm_sym59__ = (lcm_sym53__ + 1);
+              current_statement__ = 18;
+              assign(inline_sym2__,
+                cons_list(index_uni(inline_sym6__),
+                  cons_list(index_uni(lcm_sym53__), nil_index_list())),
+                stan::math::fma(
+                  (rvalue(phi,
+                     cons_list(index_uni(inline_sym6__),
+                       cons_list(index_uni(lcm_sym53__), nil_index_list())),
+                     "phi") *
+                    (1 -
+                      rvalue(p,
+                        cons_list(index_uni(inline_sym6__),
+                          cons_list(index_uni((lcm_sym59__ - 1)),
+                            nil_index_list())), "p"))),
+                  rvalue(inline_sym2__,
+                    cons_list(index_uni(inline_sym6__),
+                      cons_list(index_uni(lcm_sym59__), nil_index_list())),
+                    "inline_sym2__"),
+                  (1 -
+                    rvalue(phi,
+                      cons_list(index_uni(inline_sym6__),
+                        cons_list(index_uni(lcm_sym53__), nil_index_list())),
+                      "phi"))), "assigning variable inline_sym2__");}
+          } 
+          if (inline_sym7__) {
+            break;
+          } }
+        if (inline_sym7__) {
+          break;
+        } 
+        inline_sym7__ = 1;
+        assign(inline_sym1__, nil_index_list(), inline_sym2__,
+          "assigning variable inline_sym1__");
+        break;}
+      assign(chi, nil_index_list(), inline_sym1__, "assigning variable chi");
+      if (lcm_sym48__) {
+        if (lcm_sym47__) {
+          vars__.push_back(
+            rvalue(phi,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "phi"));
+          for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+            vars__.push_back(
+              rvalue(phi,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "phi"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= lcm_sym54__; ++sym1__) {
+          if (lcm_sym47__) {
+            vars__.push_back(
+              rvalue(phi,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())), "phi"));
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              vars__.push_back(
+                rvalue(phi,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())), "phi"));
+            }
+          } }
+      } 
+      if (lcm_sym48__) {
+        if (lcm_sym47__) {
+          vars__.push_back(
+            rvalue(p,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "p"));
+          for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+            vars__.push_back(
+              rvalue(p,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "p"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= lcm_sym54__; ++sym1__) {
+          if (lcm_sym47__) {
+            vars__.push_back(
+              rvalue(p,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())), "p"));
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              vars__.push_back(
+                rvalue(p,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())), "p"));}
+          } }
+      } 
+      if (logical_gte(n_occasions, 1)) {
+        if (lcm_sym47__) {
+          vars__.push_back(
+            rvalue(inline_sym1__,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "inline_sym1__"));
+          for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+            vars__.push_back(
+              rvalue(inline_sym1__,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())),
+                "inline_sym1__"));}
+        } 
+        for (int sym1__ = 2; sym1__ <= n_occasions; ++sym1__) {
+          if (lcm_sym47__) {
+            vars__.push_back(
+              rvalue(inline_sym1__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                "inline_sym1__"));
+            for (int sym2__ = 2; sym2__ <= nind; ++sym2__) {
+              vars__.push_back(
+                rvalue(inline_sym1__,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  "inline_sym1__"));}
+          } }
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double mean_phi;
+      mean_phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      mean_phi = context__.vals_r("mean_phi")[(1 - 1)];
+      current_statement__ = 1;
+      mean_phi = stan::math::lub_free(mean_phi, 0, 1);
+      double mean_p;
+      mean_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      mean_p = context__.vals_r("mean_p")[(1 - 1)];
+      current_statement__ = 2;
+      mean_p = stan::math::lub_free(mean_p, 0, 1);
+      vars__.push_back(mean_phi);
+      vars__.push_back(mean_p);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("mean_phi");
+    names__.push_back("mean_p");
+    names__.push_back("phi");
+    names__.push_back("p");
+    names__.push_back("chi");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(nind);
+    
+    dims__.push_back(n_occ_minus_1);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(nind);
+    
+    dims__.push_back(n_occ_minus_1);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(nind);
+    
+    dims__.push_back(n_occasions);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mean_phi");
+    param_names__.push_back(std::string() + "mean_p");
+    if (emit_transformed_parameters__) {
+      for (int sym139__ = 1; sym139__ <= n_occ_minus_1; ++sym139__) {
+        {
+          for (int sym140__ = 1; sym140__ <= nind; ++sym140__) {
+            {
+              param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym140__) + '.' + std::to_string(sym139__));
+            }}
+        }}
+      for (int sym139__ = 1; sym139__ <= n_occ_minus_1; ++sym139__) {
+        {
+          for (int sym140__ = 1; sym140__ <= nind; ++sym140__) {
+            {
+              param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym140__) + '.' + std::to_string(sym139__));
+            }}
+        }}
+      for (int sym139__ = 1; sym139__ <= n_occasions; ++sym139__) {
+        {
+          for (int sym140__ = 1; sym140__ <= nind; ++sym140__) {
+            {
+              param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym140__) + '.' + std::to_string(sym139__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "mean_phi");
+    param_names__.push_back(std::string() + "mean_p");
+    if (emit_transformed_parameters__) {
+      for (int sym139__ = 1; sym139__ <= n_occ_minus_1; ++sym139__) {
+        {
+          for (int sym140__ = 1; sym140__ <= nind; ++sym140__) {
+            {
+              param_names__.push_back(std::string() + "phi" + '.' + std::to_string(sym140__) + '.' + std::to_string(sym139__));
+            }}
+        }}
+      for (int sym139__ = 1; sym139__ <= n_occ_minus_1; ++sym139__) {
+        {
+          for (int sym140__ = 1; sym140__ <= nind; ++sym140__) {
+            {
+              param_names__.push_back(std::string() + "p" + '.' + std::to_string(sym140__) + '.' + std::to_string(sym139__));
+            }}
+        }}
+      for (int sym139__ = 1; sym139__ <= n_occasions; ++sym139__) {
+        {
+          for (int sym140__ = 1; sym140__ <= nind; ++sym140__) {
+            {
+              param_names__.push_back(std::string() + "chi" + '.' + std::to_string(sym140__) + '.' + std::to_string(sym139__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"mean_phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mean_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"p\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occ_minus_1 << "},\"block\":\"transformed_parameters\"},{\"name\":\"chi\",\"type\":{\"name\":\"matrix\",\"rows\":" << nind << ",\"cols\":" << n_occasions << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef lcm_fails2_model_namespace::lcm_fails2_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp off-dce.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace off_dce_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'off-dce.stan', line 23, column 2 to column 17)",
+                                                      " (in 'off-dce.stan', line 24, column 2 to column 16)",
+                                                      " (in 'off-dce.stan', line 25, column 2 to column 15)",
+                                                      " (in 'off-dce.stan', line 26, column 2 to column 14)",
+                                                      " (in 'off-dce.stan', line 30, column 2 to column 22)",
+                                                      " (in 'off-dce.stan', line 31, column 2 to column 23)",
+                                                      " (in 'off-dce.stan', line 58, column 2 to column 13)",
+                                                      " (in 'off-dce.stan', line 59, column 2 to column 18)",
+                                                      " (in 'off-dce.stan', line 60, column 2 to column 11)",
+                                                      " (in 'off-dce.stan', line 70, column 6 to column 21)",
+                                                      " (in 'off-dce.stan', line 71, column 6 to column 15)",
+                                                      " (in 'off-dce.stan', line 69, column 11 to line 72, column 5)",
+                                                      " (in 'off-dce.stan', line 64, column 6 to column 41)",
+                                                      " (in 'off-dce.stan', line 65, column 6 to column 44)",
+                                                      " (in 'off-dce.stan', line 66, column 6 to column 26)",
+                                                      " (in 'off-dce.stan', line 67, column 6 to column 55)",
+                                                      " (in 'off-dce.stan', line 68, column 6 to column 39)",
+                                                      " (in 'off-dce.stan', line 63, column 23 to line 69, column 5)",
+                                                      " (in 'off-dce.stan', line 63, column 4 to line 72, column 5)",
+                                                      " (in 'off-dce.stan', line 62, column 17 to line 73, column 3)",
+                                                      " (in 'off-dce.stan', line 62, column 2 to line 73, column 3)",
+                                                      " (in 'off-dce.stan', line 49, column 6 to line 52, column 68)",
+                                                      " (in 'off-dce.stan', line 47, column 11 to line 53, column 5)",
+                                                      " (in 'off-dce.stan', line 45, column 6 to column 40)",
+                                                      " (in 'off-dce.stan', line 46, column 6 to column 41)",
+                                                      " (in 'off-dce.stan', line 44, column 18 to line 47, column 5)",
+                                                      " (in 'off-dce.stan', line 44, column 4 to line 53, column 5)",
+                                                      " (in 'off-dce.stan', line 43, column 17 to line 54, column 3)",
+                                                      " (in 'off-dce.stan', line 43, column 2 to line 54, column 3)",
+                                                      " (in 'off-dce.stan', line 4, column 2 to column 17)",
+                                                      " (in 'off-dce.stan', line 5, column 2 to column 17)",
+                                                      " (in 'off-dce.stan', line 6, column 2 to column 31)",
+                                                      " (in 'off-dce.stan', line 7, column 2 to column 14)",
+                                                      " (in 'off-dce.stan', line 11, column 2 to column 32)",
+                                                      " (in 'off-dce.stan', line 12, column 2 to column 31)",
+                                                      " (in 'off-dce.stan', line 14, column 2 to column 14)",
+                                                      " (in 'off-dce.stan', line 16, column 4 to column 25)",
+                                                      " (in 'off-dce.stan', line 18, column 6 to column 28)",
+                                                      " (in 'off-dce.stan', line 17, column 4 to line 18, column 28)",
+                                                      " (in 'off-dce.stan', line 15, column 17 to line 19, column 3)",
+                                                      " (in 'off-dce.stan', line 15, column 2 to line 19, column 3)"};
+
+
+
+class off_dce_model : public model_base_crtp<off_dce_model> {
+
+ private:
+  int lcm_sym57__;
+  int lcm_sym56__;
+  int lcm_sym55__;
+  int lcm_sym54__;
+  int lcm_sym53__;
+  int lcm_sym52__;
+  int lcm_sym51__;
+  int lcm_sym50__;
+  int lcm_sym49__;
+  double lcm_sym48__;
+  double lcm_sym47__;
+  int lcm_sym46__;
+  int lcm_sym45__;
+  int lcm_sym44__;
+  int lcm_sym43__;
+  int lcm_sym42__;
+  int lcm_sym41__;
+  int pos__;
+  int R;
+  int T;
+  std::vector<std::vector<int>> y;
+  Eigen::Matrix<double, -1, 1> X;
+  std::vector<int> sum_y;
+  int occ_obs;
+ 
+ public:
+  ~off_dce_model() { }
+  
+  std::string model_name() const { return "off_dce_model"; }
+  
+  off_dce_model(stan::io::var_context& context__,
+                unsigned int random_seed__ = 0,
+                std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "off_dce_model_namespace::off_dce_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","R","int",
+          context__.to_vec());
+      R = std::numeric_limits<int>::min();
+      
+      current_statement__ = 30;
+      R = context__.vals_i("R")[(1 - 1)];
+      context__.validate_dims("data initialization","T","int",
+          context__.to_vec());
+      T = std::numeric_limits<int>::min();
+      
+      current_statement__ = 31;
+      T = context__.vals_i("T")[(1 - 1)];
+      current_statement__ = 32;
+      validate_non_negative_index("y", "R", R);
+      current_statement__ = 32;
+      validate_non_negative_index("y", "T", T);
+      context__.validate_dims("data initialization","y","int",
+          context__.to_vec(R, T));
+      y = std::vector<std::vector<int>>(R, std::vector<int>(T, std::numeric_limits<int>::min()));
+      
+      {
+        std::vector<int> y_flat__;
+        current_statement__ = 32;
+        assign(y_flat__, nil_index_list(), context__.vals_i("y"),
+          "assigning variable y_flat__");
+        current_statement__ = 32;
+        pos__ = 1;
+        lcm_sym42__ = logical_gte(T, 1);
+        if (lcm_sym42__) {
+          {
+            lcm_sym41__ = logical_gte(R, 1);
+            if (lcm_sym41__) {
+              current_statement__ = 32;
+              assign(y,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(1), nil_index_list())),
+                rvalue(y_flat__, cons_list(index_uni(1), nil_index_list()),
+                  "y_flat__"), "assigning variable y");
+              current_statement__ = 32;
+              pos__ = 2;
+              for (int sym2__ = 2; sym2__ <= R; ++sym2__) {
+                current_statement__ = 32;
+                assign(y,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(1), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 32;
+                pos__ = (pos__ + 1);}
+            } 
+            for (int sym1__ = 2; sym1__ <= T; ++sym1__) {
+              current_statement__ = 32;
+              if (lcm_sym41__) {
+                current_statement__ = 32;
+                assign(y,
+                  cons_list(index_uni(1),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  y_flat__[(pos__ - 1)], "assigning variable y");
+                current_statement__ = 32;
+                pos__ = (pos__ + 1);
+                for (int sym2__ = 2; sym2__ <= R; ++sym2__) {
+                  current_statement__ = 32;
+                  assign(y,
+                    cons_list(index_uni(sym2__),
+                      cons_list(index_uni(sym1__), nil_index_list())),
+                    y_flat__[(pos__ - 1)], "assigning variable y");
+                  current_statement__ = 32;
+                  pos__ = (pos__ + 1);}
+              } }
+          }
+        } else {
+          lcm_sym41__ = logical_gte(R, 1);
+        }
+      }
+      current_statement__ = 33;
+      validate_non_negative_index("X", "R", R);
+      context__.validate_dims("data initialization","X","double",
+          context__.to_vec(R));
+      X = Eigen::Matrix<double, -1, 1>(R);
+      stan::math::fill(X, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> X_flat__;
+        current_statement__ = 33;
+        assign(X_flat__, nil_index_list(), context__.vals_r("X"),
+          "assigning variable X_flat__");
+        current_statement__ = 33;
+        pos__ = 1;
+        current_statement__ = 33;
+        if (lcm_sym41__) {
+          current_statement__ = 33;
+          assign(X, cons_list(index_uni(1), nil_index_list()),
+            rvalue(X_flat__, cons_list(index_uni(1), nil_index_list()),
+              "X_flat__"), "assigning variable X");
+          current_statement__ = 33;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= R; ++sym1__) {
+            current_statement__ = 33;
+            assign(X, cons_list(index_uni(sym1__), nil_index_list()),
+              X_flat__[(pos__ - 1)], "assigning variable X");
+            current_statement__ = 33;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 34;
+      validate_non_negative_index("sum_y", "R", R);
+      sum_y = std::vector<int>(R, std::numeric_limits<int>::min());
+      
+      occ_obs = std::numeric_limits<int>::min();
+      
+      current_statement__ = 36;
+      occ_obs = 0;
+      current_statement__ = 41;
+      if (lcm_sym41__) {
+        current_statement__ = 37;
+        assign(sum_y, cons_list(index_uni(1), nil_index_list()),
+          sum(rvalue(y, cons_list(index_uni(1), nil_index_list()), "y")),
+          "assigning variable sum_y");
+        current_statement__ = 39;
+        if (rvalue(sum_y, cons_list(index_uni(1), nil_index_list()), "sum_y")) {
+          current_statement__ = 38;
+          occ_obs = 1;
+        } 
+        for (int i = 2; i <= R; ++i) {
+          current_statement__ = 37;
+          assign(sum_y, cons_list(index_uni(i), nil_index_list()),
+            sum(rvalue(y, cons_list(index_uni(i), nil_index_list()), "y")),
+            "assigning variable sum_y");
+          current_statement__ = 39;
+          if (rvalue(sum_y, cons_list(index_uni(i), nil_index_list()),
+                "sum_y")) {
+            current_statement__ = 38;
+            occ_obs = (occ_obs + 1);
+          } }
+      } 
+      current_statement__ = 30;
+      current_statement__ = 30;
+      check_greater_or_equal(function__, "R", R, 1);
+      current_statement__ = 31;
+      current_statement__ = 31;
+      check_greater_or_equal(function__, "T", T, 1);
+      current_statement__ = 32;
+      if (lcm_sym41__) {
+        current_statement__ = 32;
+        if (lcm_sym42__) {
+          current_statement__ = 32;
+          current_statement__ = 32;
+          check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                 rvalue(y,
+                                   cons_list(index_uni(1),
+                                     cons_list(index_uni(1),
+                                       nil_index_list())), "y"), 0);
+          for (int sym2__ = 2; sym2__ <= T; ++sym2__) {
+            current_statement__ = 32;
+            current_statement__ = 32;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(1),
+                                       cons_list(index_uni(sym2__),
+                                         nil_index_list())), "y"), 0);}
+        } 
+        for (int sym1__ = 2; sym1__ <= R; ++sym1__) {
+          current_statement__ = 32;
+          if (lcm_sym42__) {
+            current_statement__ = 32;
+            current_statement__ = 32;
+            check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                   rvalue(y,
+                                     cons_list(index_uni(sym1__),
+                                       cons_list(index_uni(1),
+                                         nil_index_list())), "y"), 0);
+            for (int sym2__ = 2; sym2__ <= T; ++sym2__) {
+              current_statement__ = 32;
+              current_statement__ = 32;
+              check_greater_or_equal(function__, "y[sym1__, sym2__]",
+                                     y[(sym1__ - 1)][(sym2__ - 1)], 0);}
+          } }
+      } 
+      current_statement__ = 32;
+      if (lcm_sym41__) {
+        current_statement__ = 32;
+        if (lcm_sym42__) {
+          current_statement__ = 32;
+          current_statement__ = 32;
+          check_less_or_equal(function__, "y[sym1__, sym2__]",
+                              rvalue(y,
+                                cons_list(index_uni(1),
+                                  cons_list(index_uni(1), nil_index_list())),
+                                "y"), 1);
+          for (int sym2__ = 2; sym2__ <= T; ++sym2__) {
+            current_statement__ = 32;
+            current_statement__ = 32;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(1),
+                                    cons_list(index_uni(sym2__),
+                                      nil_index_list())), "y"), 1);}
+        } 
+        for (int sym1__ = 2; sym1__ <= R; ++sym1__) {
+          current_statement__ = 32;
+          if (lcm_sym42__) {
+            current_statement__ = 32;
+            current_statement__ = 32;
+            check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                rvalue(y,
+                                  cons_list(index_uni(sym1__),
+                                    cons_list(index_uni(1), nil_index_list())),
+                                  "y"), 1);
+            for (int sym2__ = 2; sym2__ <= T; ++sym2__) {
+              current_statement__ = 32;
+              current_statement__ = 32;
+              check_less_or_equal(function__, "y[sym1__, sym2__]",
+                                  y[(sym1__ - 1)][(sym2__ - 1)], 1);}
+          } }
+      } 
+      current_statement__ = 34;
+      if (lcm_sym41__) {
+        current_statement__ = 34;
+        current_statement__ = 34;
+        check_greater_or_equal(function__, "sum_y[sym1__]",
+                               rvalue(sum_y,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "sum_y"), 0);
+        for (int sym1__ = 2; sym1__ <= R; ++sym1__) {
+          current_statement__ = 34;
+          current_statement__ = 34;
+          check_greater_or_equal(function__, "sum_y[sym1__]",
+                                 sum_y[(sym1__ - 1)], 0);}
+      } 
+      current_statement__ = 34;
+      if (lcm_sym41__) {
+        current_statement__ = 34;
+        current_statement__ = 34;
+        check_less_or_equal(function__, "sum_y[sym1__]",
+                            rvalue(sum_y,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "sum_y"), T);
+        for (int sym1__ = 2; sym1__ <= R; ++sym1__) {
+          current_statement__ = 34;
+          current_statement__ = 34;
+          check_less_or_equal(function__, "sum_y[sym1__]",
+                              sum_y[(sym1__ - 1)], T);}
+      } 
+      current_statement__ = 35;
+      current_statement__ = 35;
+      check_greater_or_equal(function__, "occ_obs", occ_obs, 0);
+      current_statement__ = 35;
+      current_statement__ = 35;
+      check_less_or_equal(function__, "occ_obs", occ_obs, R);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "off_dce_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      int lcm_sym40__;
+      int lcm_sym39__;
+      Eigen::Matrix<local_scalar_t__, -1, -1> lcm_sym38__;
+      double lcm_sym37__;
+      double lcm_sym36__;
+      double lcm_sym35__;
+      double lcm_sym34__;
+      double lcm_sym33__;
+      double lcm_sym32__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym31__;
+      int lcm_sym30__;
+      local_scalar_t__ alpha_occ;
+      alpha_occ = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      alpha_occ = in__.scalar();
+      local_scalar_t__ beta_occ;
+      beta_occ = DUMMY_VAR__;
+      
+      current_statement__ = 2;
+      beta_occ = in__.scalar();
+      local_scalar_t__ alpha_p;
+      alpha_p = DUMMY_VAR__;
+      
+      current_statement__ = 3;
+      alpha_p = in__.scalar();
+      local_scalar_t__ beta_p;
+      beta_p = DUMMY_VAR__;
+      
+      current_statement__ = 4;
+      beta_p = in__.scalar();
+      current_statement__ = 5;
+      validate_non_negative_index("logit_psi", "R", R);
+      Eigen::Matrix<local_scalar_t__, -1, 1> logit_psi;
+      logit_psi = Eigen::Matrix<local_scalar_t__, -1, 1>(R);
+      stan::math::fill(logit_psi, DUMMY_VAR__);
+      
+      current_statement__ = 6;
+      validate_non_negative_index("logit_p", "R", R);
+      current_statement__ = 6;
+      validate_non_negative_index("logit_p", "T", T);
+      Eigen::Matrix<local_scalar_t__, -1, -1> logit_p;
+      logit_p = Eigen::Matrix<local_scalar_t__, -1, -1>(R, T);
+      stan::math::fill(logit_p, DUMMY_VAR__);
+      
+      assign(lcm_sym31__, nil_index_list(),
+        add(alpha_occ, multiply(beta_occ, X)),
+        "assigning variable lcm_sym31__");
+      assign(logit_psi, nil_index_list(), lcm_sym31__,
+        "assigning variable logit_psi");
+      assign(lcm_sym38__, nil_index_list(),
+        rep_matrix(add(alpha_p, multiply(beta_p, X)), T),
+        "assigning variable lcm_sym38__");
+      assign(logit_p, nil_index_list(), lcm_sym38__,
+        "assigning variable logit_p");
+      {
+        current_statement__ = 29;
+        if (logical_gte(R, 1)) {
+          current_statement__ = 27;
+          if (rvalue(sum_y, cons_list(index_uni(1), nil_index_list()),
+                "sum_y")) {
+            current_statement__ = 24;
+            lp_accum__.add(
+              bernoulli_logit_log<propto__>(1,
+                rvalue(lcm_sym31__,
+                  cons_list(index_uni(1), nil_index_list()), "lcm_sym31__")));
+            current_statement__ = 25;
+            lp_accum__.add(
+              bernoulli_logit_log<propto__>(
+                rvalue(y, cons_list(index_uni(1), nil_index_list()), "y"),
+                rvalue(lcm_sym38__,
+                  cons_list(index_uni(1), nil_index_list()), "lcm_sym38__")));
+          } else {
+            current_statement__ = 22;
+            lp_accum__.add(
+              log_sum_exp(
+                (bernoulli_logit_lpmf<false>(1,
+                   rvalue(lcm_sym31__,
+                     cons_list(index_uni(1), nil_index_list()),
+                     "lcm_sym31__")) +
+                  bernoulli_logit_lpmf<false>(0,
+                    rvalue(lcm_sym38__,
+                      cons_list(index_uni(1), nil_index_list()),
+                      "lcm_sym38__"))),
+                bernoulli_logit_lpmf<false>(0,
+                  rvalue(lcm_sym31__,
+                    cons_list(index_uni(1), nil_index_list()), "lcm_sym31__"))));
+          }
+          for (int i = 2; i <= R; ++i) {
+            current_statement__ = 27;
+            if (rvalue(sum_y, cons_list(index_uni(i), nil_index_list()),
+                  "sum_y")) {
+              current_statement__ = 24;
+              lp_accum__.add(
+                bernoulli_logit_log<propto__>(1,
+                  rvalue(lcm_sym31__,
+                    cons_list(index_uni(i), nil_index_list()), "lcm_sym31__")));
+              current_statement__ = 25;
+              lp_accum__.add(
+                bernoulli_logit_log<propto__>(
+                  rvalue(y, cons_list(index_uni(i), nil_index_list()), "y"),
+                  rvalue(lcm_sym38__,
+                    cons_list(index_uni(i), nil_index_list()), "lcm_sym38__")));
+            } else {
+              current_statement__ = 22;
+              lp_accum__.add(
+                log_sum_exp(
+                  (bernoulli_logit_lpmf<false>(1,
+                     rvalue(lcm_sym31__,
+                       cons_list(index_uni(i), nil_index_list()),
+                       "lcm_sym31__")) +
+                    bernoulli_logit_lpmf<false>(0,
+                      rvalue(lcm_sym38__,
+                        cons_list(index_uni(i), nil_index_list()),
+                        "lcm_sym38__"))),
+                  bernoulli_logit_lpmf<false>(0,
+                    rvalue(lcm_sym31__,
+                      cons_list(index_uni(i), nil_index_list()),
+                      "lcm_sym31__"))));
+            }}
+        } 
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "off_dce_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym29__;
+      double lcm_sym28__;
+      double lcm_sym27__;
+      double lcm_sym26__;
+      double lcm_sym25__;
+      double lcm_sym24__;
+      int lcm_sym23__;
+      int lcm_sym22__;
+      double lcm_sym21__;
+      double lcm_sym20__;
+      double lcm_sym12__;
+      int lcm_sym19__;
+      Eigen::Matrix<double, -1, -1> lcm_sym18__;
+      double lcm_sym17__;
+      double lcm_sym16__;
+      local_scalar_t__ lcm_sym15__;
+      local_scalar_t__ lcm_sym14__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym11__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym10__;
+      Eigen::Matrix<double, -1, 1> lcm_sym9__;
+      int lcm_sym8__;
+      int lcm_sym7__;
+      int lcm_sym6__;
+      int lcm_sym5__;
+      int lcm_sym4__;
+      int lcm_sym3__;
+      double lcm_sym2__;
+      double lcm_sym1__;
+      double alpha_occ;
+      alpha_occ = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      alpha_occ = in__.scalar();
+      double beta_occ;
+      beta_occ = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      beta_occ = in__.scalar();
+      double alpha_p;
+      alpha_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      alpha_p = in__.scalar();
+      double beta_p;
+      beta_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      beta_p = in__.scalar();
+      current_statement__ = 5;
+      validate_non_negative_index("logit_psi", "R", R);
+      Eigen::Matrix<double, -1, 1> logit_psi;
+      logit_psi = Eigen::Matrix<double, -1, 1>(R);
+      stan::math::fill(logit_psi, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 6;
+      validate_non_negative_index("logit_p", "R", R);
+      current_statement__ = 6;
+      validate_non_negative_index("logit_p", "T", T);
+      Eigen::Matrix<double, -1, -1> logit_p;
+      logit_p = Eigen::Matrix<double, -1, -1>(R, T);
+      stan::math::fill(logit_p, std::numeric_limits<double>::quiet_NaN());
+      
+      vars__.push_back(alpha_occ);
+      vars__.push_back(beta_occ);
+      vars__.push_back(alpha_p);
+      vars__.push_back(beta_p);
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      assign(lcm_sym9__, nil_index_list(),
+        add(alpha_occ, multiply(beta_occ, X)),
+        "assigning variable lcm_sym9__");
+      assign(logit_psi, nil_index_list(), lcm_sym9__,
+        "assigning variable logit_psi");
+      assign(lcm_sym18__, nil_index_list(),
+        rep_matrix(add(alpha_p, multiply(beta_p, X)), T),
+        "assigning variable lcm_sym18__");
+      assign(logit_p, nil_index_list(), lcm_sym18__,
+        "assigning variable logit_p");
+      lcm_sym5__ = logical_gte(R, 1);
+      if (lcm_sym5__) {
+        vars__.push_back(
+          rvalue(lcm_sym9__, cons_list(index_uni(1), nil_index_list()),
+            "lcm_sym9__"));
+        for (int sym1__ = 2; sym1__ <= R; ++sym1__) {
+          vars__.push_back(lcm_sym9__[(sym1__ - 1)]);}
+      } 
+      if (logical_gte(T, 1)) {
+        if (lcm_sym5__) {
+          vars__.push_back(
+            rvalue(lcm_sym18__,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "lcm_sym18__"));
+          for (int sym2__ = 2; sym2__ <= R; ++sym2__) {
+            vars__.push_back(
+              rvalue(lcm_sym18__,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "lcm_sym18__"));
+          }
+        } 
+        for (int sym1__ = 2; sym1__ <= T; ++sym1__) {
+          if (lcm_sym5__) {
+            vars__.push_back(
+              rvalue(lcm_sym18__,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(sym1__), nil_index_list())),
+                "lcm_sym18__"));
+            for (int sym2__ = 2; sym2__ <= R; ++sym2__) {
+              vars__.push_back(
+                rvalue(lcm_sym18__,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(sym1__), nil_index_list())),
+                  "lcm_sym18__"));}
+          } }
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+      int occ_fs;
+      occ_fs = std::numeric_limits<int>::min();
+      
+      current_statement__ = 8;
+      validate_non_negative_index("psi_con", "R", R);
+      std::vector<local_scalar_t__> psi_con;
+      psi_con = std::vector<local_scalar_t__>(R, DUMMY_VAR__);
+      
+      current_statement__ = 9;
+      validate_non_negative_index("z", "R", R);
+      std::vector<int> z;
+      z = std::vector<int>(R, std::numeric_limits<int>::min());
+      
+      current_statement__ = 21;
+      if (lcm_sym5__) {
+        current_statement__ = 19;
+        if (logical_eq(
+              rvalue(sum_y, cons_list(index_uni(1), nil_index_list()),
+                "sum_y"), 0)) {
+          double psi;
+          psi = std::numeric_limits<double>::quiet_NaN();
+          
+          lcm_sym15__ = inv_logit(
+                          rvalue(lcm_sym9__,
+                            cons_list(index_uni(1), nil_index_list()),
+                            "lcm_sym9__"));
+          current_statement__ = 14;
+          validate_non_negative_index("q", "T", T);
+          Eigen::Matrix<double, -1, 1> q;
+          q = Eigen::Matrix<double, -1, 1>(T);
+          stan::math::fill(q, std::numeric_limits<double>::quiet_NaN());
+          
+          assign(lcm_sym11__, nil_index_list(),
+            transpose(
+              inv_logit(
+                minus(
+                  rvalue(lcm_sym18__,
+                    cons_list(index_uni(1), nil_index_list()), "lcm_sym18__")))),
+            "assigning variable lcm_sym11__");
+          double qT;
+          qT = std::numeric_limits<double>::quiet_NaN();
+          
+          lcm_sym17__ = prod(lcm_sym11__);
+          current_statement__ = 16;
+          assign(psi_con, cons_list(index_uni(1), nil_index_list()),
+            ((lcm_sym15__ * lcm_sym17__) /
+              stan::math::fma(lcm_sym15__, lcm_sym17__, (1 - lcm_sym15__))),
+            "assigning variable psi_con");
+          current_statement__ = 17;
+          assign(z, cons_list(index_uni(1), nil_index_list()),
+            bernoulli_rng(
+              rvalue(psi_con, cons_list(index_uni(1), nil_index_list()),
+                "psi_con"), base_rng__), "assigning variable z");
+        } else {
+          current_statement__ = 10;
+          assign(psi_con, cons_list(index_uni(1), nil_index_list()), 1,
+            "assigning variable psi_con");
+          current_statement__ = 11;
+          assign(z, cons_list(index_uni(1), nil_index_list()), 1,
+            "assigning variable z");
+        }
+        for (int i = 2; i <= R; ++i) {
+          current_statement__ = 19;
+          if (logical_eq(
+                rvalue(sum_y, cons_list(index_uni(i), nil_index_list()),
+                  "sum_y"), 0)) {
+            double psi;
+            psi = std::numeric_limits<double>::quiet_NaN();
+            
+            lcm_sym14__ = inv_logit(
+                            rvalue(lcm_sym9__,
+                              cons_list(index_uni(i), nil_index_list()),
+                              "lcm_sym9__"));
+            current_statement__ = 14;
+            validate_non_negative_index("q", "T", T);
+            Eigen::Matrix<double, -1, 1> q;
+            q = Eigen::Matrix<double, -1, 1>(T);
+            stan::math::fill(q, std::numeric_limits<double>::quiet_NaN());
+            
+            assign(lcm_sym10__, nil_index_list(),
+              transpose(
+                inv_logit(
+                  minus(
+                    rvalue(lcm_sym18__,
+                      cons_list(index_uni(i), nil_index_list()),
+                      "lcm_sym18__")))), "assigning variable lcm_sym10__");
+            double qT;
+            qT = std::numeric_limits<double>::quiet_NaN();
+            
+            lcm_sym16__ = prod(lcm_sym10__);
+            current_statement__ = 16;
+            assign(psi_con, cons_list(index_uni(i), nil_index_list()),
+              ((lcm_sym14__ * lcm_sym16__) /
+                stan::math::fma(lcm_sym14__, lcm_sym16__, (1 - lcm_sym14__))),
+              "assigning variable psi_con");
+            current_statement__ = 17;
+            assign(z, cons_list(index_uni(i), nil_index_list()),
+              bernoulli_rng(
+                rvalue(psi_con, cons_list(index_uni(i), nil_index_list()),
+                  "psi_con"), base_rng__), "assigning variable z");
+          } else {
+            current_statement__ = 10;
+            assign(psi_con, cons_list(index_uni(i), nil_index_list()), 1,
+              "assigning variable psi_con");
+            current_statement__ = 11;
+            assign(z, cons_list(index_uni(i), nil_index_list()), 1,
+              "assigning variable z");
+          }}
+      } 
+      lcm_sym19__ = sum(z);
+      occ_fs = lcm_sym19__;
+      vars__.push_back(lcm_sym19__);
+      if (lcm_sym5__) {
+        vars__.push_back(
+          rvalue(psi_con, cons_list(index_uni(1), nil_index_list()),
+            "psi_con"));
+        for (int sym1__ = 2; sym1__ <= R; ++sym1__) {
+          vars__.push_back(psi_con[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym5__) {
+        vars__.push_back(
+          rvalue(z, cons_list(index_uni(1), nil_index_list()), "z"));
+        for (int sym1__ = 2; sym1__ <= R; ++sym1__) {
+          vars__.push_back(z[(sym1__ - 1)]);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double alpha_occ;
+      alpha_occ = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      alpha_occ = context__.vals_r("alpha_occ")[(1 - 1)];
+      double beta_occ;
+      beta_occ = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      beta_occ = context__.vals_r("beta_occ")[(1 - 1)];
+      double alpha_p;
+      alpha_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      alpha_p = context__.vals_r("alpha_p")[(1 - 1)];
+      double beta_p;
+      beta_p = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      beta_p = context__.vals_r("beta_p")[(1 - 1)];
+      vars__.push_back(alpha_occ);
+      vars__.push_back(beta_occ);
+      vars__.push_back(alpha_p);
+      vars__.push_back(beta_p);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("alpha_occ");
+    names__.push_back("beta_occ");
+    names__.push_back("alpha_p");
+    names__.push_back("beta_p");
+    names__.push_back("logit_psi");
+    names__.push_back("logit_p");
+    names__.push_back("occ_fs");
+    names__.push_back("psi_con");
+    names__.push_back("z");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(R);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(R);
+    
+    dims__.push_back(T);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(R);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(R);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "alpha_occ");
+    param_names__.push_back(std::string() + "beta_occ");
+    param_names__.push_back(std::string() + "alpha_p");
+    param_names__.push_back(std::string() + "beta_p");
+    if (emit_transformed_parameters__) {
+      for (int sym58__ = 1; sym58__ <= R; ++sym58__) {
+        {
+          param_names__.push_back(std::string() + "logit_psi" + '.' + std::to_string(sym58__));
+        }}
+      for (int sym58__ = 1; sym58__ <= T; ++sym58__) {
+        {
+          for (int sym59__ = 1; sym59__ <= R; ++sym59__) {
+            {
+              param_names__.push_back(std::string() + "logit_p" + '.' + std::to_string(sym59__) + '.' + std::to_string(sym58__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      param_names__.push_back(std::string() + "occ_fs");
+      for (int sym58__ = 1; sym58__ <= R; ++sym58__) {
+        {
+          param_names__.push_back(std::string() + "psi_con" + '.' + std::to_string(sym58__));
+        }}
+      for (int sym58__ = 1; sym58__ <= R; ++sym58__) {
+        {
+          param_names__.push_back(std::string() + "z" + '.' + std::to_string(sym58__));
+        }}
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "alpha_occ");
+    param_names__.push_back(std::string() + "beta_occ");
+    param_names__.push_back(std::string() + "alpha_p");
+    param_names__.push_back(std::string() + "beta_p");
+    if (emit_transformed_parameters__) {
+      for (int sym58__ = 1; sym58__ <= R; ++sym58__) {
+        {
+          param_names__.push_back(std::string() + "logit_psi" + '.' + std::to_string(sym58__));
+        }}
+      for (int sym58__ = 1; sym58__ <= T; ++sym58__) {
+        {
+          for (int sym59__ = 1; sym59__ <= R; ++sym59__) {
+            {
+              param_names__.push_back(std::string() + "logit_p" + '.' + std::to_string(sym59__) + '.' + std::to_string(sym58__));
+            }}
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      param_names__.push_back(std::string() + "occ_fs");
+      for (int sym58__ = 1; sym58__ <= R; ++sym58__) {
+        {
+          param_names__.push_back(std::string() + "psi_con" + '.' + std::to_string(sym58__));
+        }}
+      for (int sym58__ = 1; sym58__ <= R; ++sym58__) {
+        {
+          param_names__.push_back(std::string() + "z" + '.' + std::to_string(sym58__));
+        }}
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"alpha_occ\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta_occ\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"logit_psi\",\"type\":{\"name\":\"vector\",\"length\":" << R << "},\"block\":\"transformed_parameters\"},{\"name\":\"logit_p\",\"type\":{\"name\":\"matrix\",\"rows\":" << R << ",\"cols\":" << T << "},\"block\":\"transformed_parameters\"},{\"name\":\"occ_fs\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"},{\"name\":\"psi_con\",\"type\":{\"name\":\"array\",\"length\":" << R << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"},{\"name\":\"z\",\"type\":{\"name\":\"array\",\"length\":" << R << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"alpha_occ\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta_occ\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"beta_p\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"logit_psi\",\"type\":{\"name\":\"vector\",\"length\":" << R << "},\"block\":\"transformed_parameters\"},{\"name\":\"logit_p\",\"type\":{\"name\":\"matrix\",\"rows\":" << R << ",\"cols\":" << T << "},\"block\":\"transformed_parameters\"},{\"name\":\"occ_fs\",\"type\":{\"name\":\"int\"},\"block\":\"generated_quantities\"},{\"name\":\"psi_con\",\"type\":{\"name\":\"array\",\"length\":" << R << ",\"element_type\":{\"name\":\"real\"}},\"block\":\"generated_quantities\"},{\"name\":\"z\",\"type\":{\"name\":\"array\",\"length\":" << R << ",\"element_type\":{\"name\":\"int\"}},\"block\":\"generated_quantities\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef off_dce_model_namespace::off_dce_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp off-small.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace off_small_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'off-small.stan', line 10, column 2 to column 12)",
+                                                      " (in 'off-small.stan', line 11, column 2 to column 17)",
+                                                      " (in 'off-small.stan', line 12, column 2 to column 17)",
+                                                      " (in 'off-small.stan', line 13, column 2 to column 13)",
+                                                      " (in 'off-small.stan', line 14, column 2 to column 13)",
+                                                      " (in 'off-small.stan', line 15, column 2 to column 35)",
+                                                      " (in 'off-small.stan', line 16, column 2 to column 35)",
+                                                      " (in 'off-small.stan', line 17, column 2 to column 34)",
+                                                      " (in 'off-small.stan', line 20, column 2 to column 15)",
+                                                      " (in 'off-small.stan', line 21, column 2 to column 15)",
+                                                      " (in 'off-small.stan', line 22, column 2 to column 18)",
+                                                      " (in 'off-small.stan', line 28, column 4 to line 29, column 42)",
+                                                      " (in 'off-small.stan', line 27, column 2 to line 29, column 42)",
+                                                      " (in 'off-small.stan', line 32, column 2 to column 23)",
+                                                      " (in 'off-small.stan', line 33, column 2 to column 23)",
+                                                      " (in 'off-small.stan', line 34, column 2 to column 23)",
+                                                      " (in 'off-small.stan', line 35, column 2 to column 23)",
+                                                      " (in 'off-small.stan', line 37, column 2 to column 23)",
+                                                      " (in 'off-small.stan', line 39, column 2 to column 29)",
+                                                      " (in 'off-small.stan', line 2, column 2 to column 17)",
+                                                      " (in 'off-small.stan', line 3, column 2 to column 17)",
+                                                      " (in 'off-small.stan', line 4, column 2 to column 33)",
+                                                      " (in 'off-small.stan', line 5, column 2 to column 17)",
+                                                      " (in 'off-small.stan', line 6, column 2 to column 22)",
+                                                      " (in 'off-small.stan', line 7, column 2 to column 14)"};
+
+
+
+class off_small_model : public model_base_crtp<off_small_model> {
+
+ private:
+  double lcm_sym49__;
+  double lcm_sym48__;
+  double lcm_sym47__;
+  double lcm_sym46__;
+  double lcm_sym45__;
+  double lcm_sym44__;
+  int lcm_sym43__;
+  int lcm_sym42__;
+  int lcm_sym41__;
+  int lcm_sym40__;
+  int pos__;
+  int J;
+  int N;
+  std::vector<int> person;
+  Eigen::Matrix<double, -1, 1> time;
+  Eigen::Matrix<double, -1, 1> treatment;
+  Eigen::Matrix<double, -1, 1> y;
+ 
+ public:
+  ~off_small_model() { }
+  
+  std::string model_name() const { return "off_small_model"; }
+  
+  off_small_model(stan::io::var_context& context__,
+                  unsigned int random_seed__ = 0,
+                  std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "off_small_model_namespace::off_small_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","J","int",
+          context__.to_vec());
+      J = std::numeric_limits<int>::min();
+      
+      current_statement__ = 20;
+      J = context__.vals_i("J")[(1 - 1)];
+      context__.validate_dims("data initialization","N","int",
+          context__.to_vec());
+      N = std::numeric_limits<int>::min();
+      
+      current_statement__ = 21;
+      N = context__.vals_i("N")[(1 - 1)];
+      current_statement__ = 22;
+      validate_non_negative_index("person", "N", N);
+      context__.validate_dims("data initialization","person","int",
+          context__.to_vec(N));
+      person = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 22;
+      assign(person, nil_index_list(), context__.vals_i("person"),
+        "assigning variable person");
+      current_statement__ = 23;
+      validate_non_negative_index("time", "N", N);
+      context__.validate_dims("data initialization","time","double",
+          context__.to_vec(N));
+      time = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(time, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> time_flat__;
+        current_statement__ = 23;
+        assign(time_flat__, nil_index_list(), context__.vals_r("time"),
+          "assigning variable time_flat__");
+        current_statement__ = 23;
+        pos__ = 1;
+        lcm_sym40__ = logical_gte(N, 1);
+        if (lcm_sym40__) {
+          current_statement__ = 23;
+          assign(time, cons_list(index_uni(1), nil_index_list()),
+            rvalue(time_flat__, cons_list(index_uni(1), nil_index_list()),
+              "time_flat__"), "assigning variable time");
+          current_statement__ = 23;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 23;
+            assign(time, cons_list(index_uni(sym1__), nil_index_list()),
+              time_flat__[(pos__ - 1)], "assigning variable time");
+            current_statement__ = 23;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 24;
+      validate_non_negative_index("treatment", "N", N);
+      context__.validate_dims("data initialization","treatment","double",
+          context__.to_vec(N));
+      treatment = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(treatment, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> treatment_flat__;
+        current_statement__ = 24;
+        assign(treatment_flat__, nil_index_list(),
+          context__.vals_r("treatment"),
+          "assigning variable treatment_flat__");
+        current_statement__ = 24;
+        pos__ = 1;
+        current_statement__ = 24;
+        if (lcm_sym40__) {
+          current_statement__ = 24;
+          assign(treatment, cons_list(index_uni(1), nil_index_list()),
+            rvalue(treatment_flat__,
+              cons_list(index_uni(1), nil_index_list()), "treatment_flat__"),
+            "assigning variable treatment");
+          current_statement__ = 24;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 24;
+            assign(treatment, cons_list(index_uni(sym1__), nil_index_list()),
+              treatment_flat__[(pos__ - 1)], "assigning variable treatment");
+            current_statement__ = 24;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 25;
+      validate_non_negative_index("y", "N", N);
+      context__.validate_dims("data initialization","y","double",
+          context__.to_vec(N));
+      y = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(y, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> y_flat__;
+        current_statement__ = 25;
+        assign(y_flat__, nil_index_list(), context__.vals_r("y"),
+          "assigning variable y_flat__");
+        current_statement__ = 25;
+        pos__ = 1;
+        current_statement__ = 25;
+        if (lcm_sym40__) {
+          current_statement__ = 25;
+          assign(y, cons_list(index_uni(1), nil_index_list()),
+            rvalue(y_flat__, cons_list(index_uni(1), nil_index_list()),
+              "y_flat__"), "assigning variable y");
+          current_statement__ = 25;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 25;
+            assign(y, cons_list(index_uni(sym1__), nil_index_list()),
+              y_flat__[(pos__ - 1)], "assigning variable y");
+            current_statement__ = 25;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 20;
+      current_statement__ = 20;
+      check_greater_or_equal(function__, "J", J, 0);
+      current_statement__ = 21;
+      current_statement__ = 21;
+      check_greater_or_equal(function__, "N", N, 0);
+      current_statement__ = 22;
+      if (lcm_sym40__) {
+        current_statement__ = 22;
+        current_statement__ = 22;
+        check_greater_or_equal(function__, "person[sym1__]",
+                               rvalue(person,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "person"), 1);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 22;
+          current_statement__ = 22;
+          check_greater_or_equal(function__, "person[sym1__]",
+                                 person[(sym1__ - 1)], 1);}
+      } 
+      current_statement__ = 22;
+      if (lcm_sym40__) {
+        current_statement__ = 22;
+        current_statement__ = 22;
+        check_less_or_equal(function__, "person[sym1__]",
+                            rvalue(person,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "person"), J);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 22;
+          current_statement__ = 22;
+          check_less_or_equal(function__, "person[sym1__]",
+                              person[(sym1__ - 1)], J);}
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      current_statement__ = 2;
+      validate_non_negative_index("eta1", "J", J);
+      num_params_r__ += J;
+      current_statement__ = 3;
+      validate_non_negative_index("eta2", "J", J);
+      num_params_r__ += J;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "off_small_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym39__;
+      double lcm_sym38__;
+      double lcm_sym37__;
+      double lcm_sym36__;
+      double lcm_sym35__;
+      double lcm_sym34__;
+      double lcm_sym33__;
+      double lcm_sym32__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym31__;
+      Eigen::Matrix<local_scalar_t__, -1, 1> lcm_sym30__;
+      int lcm_sym29__;
+      local_scalar_t__ beta;
+      beta = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      beta = in__.scalar();
+      current_statement__ = 2;
+      validate_non_negative_index("eta1", "J", J);
+      Eigen::Matrix<local_scalar_t__, -1, 1> eta1;
+      eta1 = Eigen::Matrix<local_scalar_t__, -1, 1>(J);
+      stan::math::fill(eta1, DUMMY_VAR__);
+      
+      current_statement__ = 2;
+      eta1 = in__.vector(J);
+      current_statement__ = 3;
+      validate_non_negative_index("eta2", "J", J);
+      Eigen::Matrix<local_scalar_t__, -1, 1> eta2;
+      eta2 = Eigen::Matrix<local_scalar_t__, -1, 1>(J);
+      stan::math::fill(eta2, DUMMY_VAR__);
+      
+      current_statement__ = 3;
+      eta2 = in__.vector(J);
+      local_scalar_t__ mu_a1;
+      mu_a1 = DUMMY_VAR__;
+      
+      current_statement__ = 4;
+      mu_a1 = in__.scalar();
+      local_scalar_t__ mu_a2;
+      mu_a2 = DUMMY_VAR__;
+      
+      current_statement__ = 5;
+      mu_a2 = in__.scalar();
+      local_scalar_t__ sigma_a1;
+      sigma_a1 = DUMMY_VAR__;
+      
+      current_statement__ = 6;
+      sigma_a1 = in__.scalar();
+      current_statement__ = 6;
+      if (jacobian__) {
+        current_statement__ = 6;
+        sigma_a1 = stan::math::lub_constrain(sigma_a1, 0, 100, lp__);
+      } else {
+        current_statement__ = 6;
+        sigma_a1 = stan::math::lub_constrain(sigma_a1, 0, 100);
+      }
+      local_scalar_t__ sigma_a2;
+      sigma_a2 = DUMMY_VAR__;
+      
+      current_statement__ = 7;
+      sigma_a2 = in__.scalar();
+      current_statement__ = 7;
+      if (jacobian__) {
+        current_statement__ = 7;
+        sigma_a2 = stan::math::lub_constrain(sigma_a2, 0, 100, lp__);
+      } else {
+        current_statement__ = 7;
+        sigma_a2 = stan::math::lub_constrain(sigma_a2, 0, 100);
+      }
+      local_scalar_t__ sigma_y;
+      sigma_y = DUMMY_VAR__;
+      
+      current_statement__ = 8;
+      sigma_y = in__.scalar();
+      current_statement__ = 8;
+      if (jacobian__) {
+        current_statement__ = 8;
+        sigma_y = stan::math::lub_constrain(sigma_y, 0, 100, lp__);
+      } else {
+        current_statement__ = 8;
+        sigma_y = stan::math::lub_constrain(sigma_y, 0, 100);
+      }
+      current_statement__ = 9;
+      validate_non_negative_index("a1", "J", J);
+      Eigen::Matrix<local_scalar_t__, -1, 1> a1;
+      a1 = Eigen::Matrix<local_scalar_t__, -1, 1>(J);
+      stan::math::fill(a1, DUMMY_VAR__);
+      
+      current_statement__ = 10;
+      validate_non_negative_index("a2", "J", J);
+      Eigen::Matrix<local_scalar_t__, -1, 1> a2;
+      a2 = Eigen::Matrix<local_scalar_t__, -1, 1>(J);
+      stan::math::fill(a2, DUMMY_VAR__);
+      
+      current_statement__ = 11;
+      validate_non_negative_index("y_hat", "N", N);
+      Eigen::Matrix<local_scalar_t__, -1, 1> y_hat;
+      y_hat = Eigen::Matrix<local_scalar_t__, -1, 1>(N);
+      stan::math::fill(y_hat, DUMMY_VAR__);
+      
+      assign(lcm_sym30__, nil_index_list(),
+        add((10 * mu_a1), multiply(sigma_a1, eta1)),
+        "assigning variable lcm_sym30__");
+      assign(a1, nil_index_list(), lcm_sym30__, "assigning variable a1");
+      assign(lcm_sym31__, nil_index_list(),
+        add((0.1 * mu_a2), multiply(sigma_a2, eta2)),
+        "assigning variable lcm_sym31__");
+      assign(a2, nil_index_list(), lcm_sym31__, "assigning variable a2");
+      current_statement__ = 13;
+      if (logical_gte(N, 1)) {
+        current_statement__ = 12;
+        assign(y_hat, cons_list(index_uni(1), nil_index_list()),
+          stan::math::fma(
+            rvalue(lcm_sym31__,
+              cons_list(
+                index_uni(rvalue(person,
+                            cons_list(index_uni(1), nil_index_list()),
+                            "person")), nil_index_list()), "lcm_sym31__"),
+            rvalue(time, cons_list(index_uni(1), nil_index_list()), "time"),
+            stan::math::fma(
+              (beta *
+                rvalue(time, cons_list(index_uni(1), nil_index_list()),
+                  "time")),
+              rvalue(treatment, cons_list(index_uni(1), nil_index_list()),
+                "treatment"),
+              rvalue(lcm_sym30__,
+                cons_list(
+                  index_uni(rvalue(person,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "person")), nil_index_list()), "lcm_sym30__"))),
+          "assigning variable y_hat");
+        for (int i = 2; i <= N; ++i) {
+          current_statement__ = 12;
+          assign(y_hat, cons_list(index_uni(i), nil_index_list()),
+            stan::math::fma(
+              rvalue(lcm_sym31__,
+                cons_list(
+                  index_uni(rvalue(person,
+                              cons_list(index_uni(i), nil_index_list()),
+                              "person")), nil_index_list()), "lcm_sym31__"),
+              rvalue(time, cons_list(index_uni(i), nil_index_list()), "time"),
+              stan::math::fma(
+                (beta *
+                  rvalue(time, cons_list(index_uni(i), nil_index_list()),
+                    "time")),
+                rvalue(treatment, cons_list(index_uni(i), nil_index_list()),
+                  "treatment"),
+                rvalue(lcm_sym30__,
+                  cons_list(
+                    index_uni(rvalue(person,
+                                cons_list(index_uni(i), nil_index_list()),
+                                "person")), nil_index_list()), "lcm_sym30__"))),
+            "assigning variable y_hat");}
+      } 
+      {
+        current_statement__ = 14;
+        lp_accum__.add(normal_log<propto__>(mu_a1, 0, 1));
+        current_statement__ = 15;
+        lp_accum__.add(normal_log<propto__>(eta1, 0, 1));
+        current_statement__ = 16;
+        lp_accum__.add(normal_log<propto__>(mu_a2, 0, 1));
+        current_statement__ = 17;
+        lp_accum__.add(normal_log<propto__>(eta2, 0, 1));
+        current_statement__ = 18;
+        lp_accum__.add(normal_log<propto__>(beta, 0, 1));
+        current_statement__ = 19;
+        lp_accum__.add(normal_log<propto__>(y, y_hat, sigma_y));
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "off_small_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym28__;
+      double lcm_sym27__;
+      double lcm_sym26__;
+      double lcm_sym25__;
+      double lcm_sym24__;
+      double lcm_sym23__;
+      double lcm_sym22__;
+      double lcm_sym21__;
+      double lcm_sym20__;
+      double lcm_sym19__;
+      double lcm_sym18__;
+      double lcm_sym17__;
+      Eigen::Matrix<double, -1, 1> lcm_sym16__;
+      Eigen::Matrix<double, -1, 1> lcm_sym15__;
+      int lcm_sym14__;
+      int lcm_sym13__;
+      int lcm_sym12__;
+      int lcm_sym11__;
+      double beta;
+      beta = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      beta = in__.scalar();
+      current_statement__ = 2;
+      validate_non_negative_index("eta1", "J", J);
+      Eigen::Matrix<double, -1, 1> eta1;
+      eta1 = Eigen::Matrix<double, -1, 1>(J);
+      stan::math::fill(eta1, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 2;
+      eta1 = in__.vector(J);
+      current_statement__ = 3;
+      validate_non_negative_index("eta2", "J", J);
+      Eigen::Matrix<double, -1, 1> eta2;
+      eta2 = Eigen::Matrix<double, -1, 1>(J);
+      stan::math::fill(eta2, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 3;
+      eta2 = in__.vector(J);
+      double mu_a1;
+      mu_a1 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      mu_a1 = in__.scalar();
+      double mu_a2;
+      mu_a2 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 5;
+      mu_a2 = in__.scalar();
+      double sigma_a1;
+      sigma_a1 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 6;
+      sigma_a1 = in__.scalar();
+      current_statement__ = 6;
+      sigma_a1 = stan::math::lub_constrain(sigma_a1, 0, 100);
+      double sigma_a2;
+      sigma_a2 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 7;
+      sigma_a2 = in__.scalar();
+      current_statement__ = 7;
+      sigma_a2 = stan::math::lub_constrain(sigma_a2, 0, 100);
+      double sigma_y;
+      sigma_y = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 8;
+      sigma_y = in__.scalar();
+      current_statement__ = 8;
+      sigma_y = stan::math::lub_constrain(sigma_y, 0, 100);
+      current_statement__ = 9;
+      validate_non_negative_index("a1", "J", J);
+      Eigen::Matrix<double, -1, 1> a1;
+      a1 = Eigen::Matrix<double, -1, 1>(J);
+      stan::math::fill(a1, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 10;
+      validate_non_negative_index("a2", "J", J);
+      Eigen::Matrix<double, -1, 1> a2;
+      a2 = Eigen::Matrix<double, -1, 1>(J);
+      stan::math::fill(a2, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 11;
+      validate_non_negative_index("y_hat", "N", N);
+      Eigen::Matrix<local_scalar_t__, -1, 1> y_hat;
+      y_hat = Eigen::Matrix<local_scalar_t__, -1, 1>(N);
+      stan::math::fill(y_hat, DUMMY_VAR__);
+      
+      vars__.push_back(beta);
+      lcm_sym11__ = logical_gte(J, 1);
+      if (lcm_sym11__) {
+        vars__.push_back(
+          rvalue(eta1, cons_list(index_uni(1), nil_index_list()), "eta1"));
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          vars__.push_back(eta1[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym11__) {
+        vars__.push_back(
+          rvalue(eta2, cons_list(index_uni(1), nil_index_list()), "eta2"));
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          vars__.push_back(eta2[(sym1__ - 1)]);}
+      } 
+      vars__.push_back(mu_a1);
+      vars__.push_back(mu_a2);
+      vars__.push_back(sigma_a1);
+      vars__.push_back(sigma_a2);
+      vars__.push_back(sigma_y);
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      assign(lcm_sym15__, nil_index_list(),
+        add((10 * mu_a1), multiply(sigma_a1, eta1)),
+        "assigning variable lcm_sym15__");
+      assign(a1, nil_index_list(), lcm_sym15__, "assigning variable a1");
+      assign(lcm_sym16__, nil_index_list(),
+        add((0.1 * mu_a2), multiply(sigma_a2, eta2)),
+        "assigning variable lcm_sym16__");
+      assign(a2, nil_index_list(), lcm_sym16__, "assigning variable a2");
+      lcm_sym12__ = logical_gte(N, 1);
+      if (lcm_sym12__) {
+        current_statement__ = 12;
+        assign(y_hat, cons_list(index_uni(1), nil_index_list()),
+          stan::math::fma(
+            rvalue(lcm_sym16__,
+              cons_list(
+                index_uni(rvalue(person,
+                            cons_list(index_uni(1), nil_index_list()),
+                            "person")), nil_index_list()), "lcm_sym16__"),
+            rvalue(time, cons_list(index_uni(1), nil_index_list()), "time"),
+            stan::math::fma(
+              (beta *
+                rvalue(time, cons_list(index_uni(1), nil_index_list()),
+                  "time")),
+              rvalue(treatment, cons_list(index_uni(1), nil_index_list()),
+                "treatment"),
+              rvalue(lcm_sym15__,
+                cons_list(
+                  index_uni(rvalue(person,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "person")), nil_index_list()), "lcm_sym15__"))),
+          "assigning variable y_hat");
+        for (int i = 2; i <= N; ++i) {
+          current_statement__ = 12;
+          assign(y_hat, cons_list(index_uni(i), nil_index_list()),
+            stan::math::fma(
+              rvalue(lcm_sym16__,
+                cons_list(
+                  index_uni(rvalue(person,
+                              cons_list(index_uni(i), nil_index_list()),
+                              "person")), nil_index_list()), "lcm_sym16__"),
+              rvalue(time, cons_list(index_uni(i), nil_index_list()), "time"),
+              stan::math::fma(
+                (beta *
+                  rvalue(time, cons_list(index_uni(i), nil_index_list()),
+                    "time")),
+                rvalue(treatment, cons_list(index_uni(i), nil_index_list()),
+                  "treatment"),
+                rvalue(lcm_sym15__,
+                  cons_list(
+                    index_uni(rvalue(person,
+                                cons_list(index_uni(i), nil_index_list()),
+                                "person")), nil_index_list()), "lcm_sym15__"))),
+            "assigning variable y_hat");}
+      } 
+      if (lcm_sym11__) {
+        vars__.push_back(
+          rvalue(lcm_sym15__, cons_list(index_uni(1), nil_index_list()),
+            "lcm_sym15__"));
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          vars__.push_back(lcm_sym15__[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym11__) {
+        vars__.push_back(
+          rvalue(lcm_sym16__, cons_list(index_uni(1), nil_index_list()),
+            "lcm_sym16__"));
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          vars__.push_back(lcm_sym16__[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym12__) {
+        vars__.push_back(
+          rvalue(y_hat, cons_list(index_uni(1), nil_index_list()), "y_hat"));
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          vars__.push_back(y_hat[(sym1__ - 1)]);}
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym10__;
+      double lcm_sym9__;
+      double lcm_sym8__;
+      double lcm_sym7__;
+      double lcm_sym6__;
+      double lcm_sym5__;
+      double lcm_sym4__;
+      double lcm_sym3__;
+      int lcm_sym2__;
+      int lcm_sym1__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double beta;
+      beta = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      beta = context__.vals_r("beta")[(1 - 1)];
+      current_statement__ = 2;
+      validate_non_negative_index("eta1", "J", J);
+      Eigen::Matrix<double, -1, 1> eta1;
+      eta1 = Eigen::Matrix<double, -1, 1>(J);
+      stan::math::fill(eta1, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> eta1_flat__;
+        current_statement__ = 2;
+        assign(eta1_flat__, nil_index_list(), context__.vals_r("eta1"),
+          "assigning variable eta1_flat__");
+        current_statement__ = 2;
+        pos__ = 1;
+        lcm_sym1__ = logical_gte(J, 1);
+        if (lcm_sym1__) {
+          current_statement__ = 2;
+          assign(eta1, cons_list(index_uni(1), nil_index_list()),
+            rvalue(eta1_flat__, cons_list(index_uni(1), nil_index_list()),
+              "eta1_flat__"), "assigning variable eta1");
+          current_statement__ = 2;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+            current_statement__ = 2;
+            assign(eta1, cons_list(index_uni(sym1__), nil_index_list()),
+              eta1_flat__[(pos__ - 1)], "assigning variable eta1");
+            current_statement__ = 2;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 3;
+      validate_non_negative_index("eta2", "J", J);
+      Eigen::Matrix<double, -1, 1> eta2;
+      eta2 = Eigen::Matrix<double, -1, 1>(J);
+      stan::math::fill(eta2, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> eta2_flat__;
+        current_statement__ = 3;
+        assign(eta2_flat__, nil_index_list(), context__.vals_r("eta2"),
+          "assigning variable eta2_flat__");
+        current_statement__ = 3;
+        pos__ = 1;
+        current_statement__ = 3;
+        if (lcm_sym1__) {
+          current_statement__ = 3;
+          assign(eta2, cons_list(index_uni(1), nil_index_list()),
+            rvalue(eta2_flat__, cons_list(index_uni(1), nil_index_list()),
+              "eta2_flat__"), "assigning variable eta2");
+          current_statement__ = 3;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+            current_statement__ = 3;
+            assign(eta2, cons_list(index_uni(sym1__), nil_index_list()),
+              eta2_flat__[(pos__ - 1)], "assigning variable eta2");
+            current_statement__ = 3;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      double mu_a1;
+      mu_a1 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      mu_a1 = context__.vals_r("mu_a1")[(1 - 1)];
+      double mu_a2;
+      mu_a2 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 5;
+      mu_a2 = context__.vals_r("mu_a2")[(1 - 1)];
+      double sigma_a1;
+      sigma_a1 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 6;
+      sigma_a1 = context__.vals_r("sigma_a1")[(1 - 1)];
+      current_statement__ = 6;
+      sigma_a1 = stan::math::lub_free(sigma_a1, 0, 100);
+      double sigma_a2;
+      sigma_a2 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 7;
+      sigma_a2 = context__.vals_r("sigma_a2")[(1 - 1)];
+      current_statement__ = 7;
+      sigma_a2 = stan::math::lub_free(sigma_a2, 0, 100);
+      double sigma_y;
+      sigma_y = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 8;
+      sigma_y = context__.vals_r("sigma_y")[(1 - 1)];
+      current_statement__ = 8;
+      sigma_y = stan::math::lub_free(sigma_y, 0, 100);
+      vars__.push_back(beta);
+      if (lcm_sym1__) {
+        vars__.push_back(
+          rvalue(eta1, cons_list(index_uni(1), nil_index_list()), "eta1"));
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          vars__.push_back(eta1[(sym1__ - 1)]);}
+      } 
+      if (lcm_sym1__) {
+        vars__.push_back(
+          rvalue(eta2, cons_list(index_uni(1), nil_index_list()), "eta2"));
+        for (int sym1__ = 2; sym1__ <= J; ++sym1__) {
+          vars__.push_back(eta2[(sym1__ - 1)]);}
+      } 
+      vars__.push_back(mu_a1);
+      vars__.push_back(mu_a2);
+      vars__.push_back(sigma_a1);
+      vars__.push_back(sigma_a2);
+      vars__.push_back(sigma_y);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("beta");
+    names__.push_back("eta1");
+    names__.push_back("eta2");
+    names__.push_back("mu_a1");
+    names__.push_back("mu_a2");
+    names__.push_back("sigma_a1");
+    names__.push_back("sigma_a2");
+    names__.push_back("sigma_y");
+    names__.push_back("a1");
+    names__.push_back("a2");
+    names__.push_back("y_hat");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(J);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(J);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(J);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(J);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(N);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "beta");
+    for (int sym50__ = 1; sym50__ <= J; ++sym50__) {
+      {
+        param_names__.push_back(std::string() + "eta1" + '.' + std::to_string(sym50__));
+      }}
+    for (int sym50__ = 1; sym50__ <= J; ++sym50__) {
+      {
+        param_names__.push_back(std::string() + "eta2" + '.' + std::to_string(sym50__));
+      }}
+    param_names__.push_back(std::string() + "mu_a1");
+    param_names__.push_back(std::string() + "mu_a2");
+    param_names__.push_back(std::string() + "sigma_a1");
+    param_names__.push_back(std::string() + "sigma_a2");
+    param_names__.push_back(std::string() + "sigma_y");
+    if (emit_transformed_parameters__) {
+      for (int sym50__ = 1; sym50__ <= J; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "a1" + '.' + std::to_string(sym50__));
+        }}
+      for (int sym50__ = 1; sym50__ <= J; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "a2" + '.' + std::to_string(sym50__));
+        }}
+      for (int sym50__ = 1; sym50__ <= N; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "y_hat" + '.' + std::to_string(sym50__));
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "beta");
+    for (int sym50__ = 1; sym50__ <= J; ++sym50__) {
+      {
+        param_names__.push_back(std::string() + "eta1" + '.' + std::to_string(sym50__));
+      }}
+    for (int sym50__ = 1; sym50__ <= J; ++sym50__) {
+      {
+        param_names__.push_back(std::string() + "eta2" + '.' + std::to_string(sym50__));
+      }}
+    param_names__.push_back(std::string() + "mu_a1");
+    param_names__.push_back(std::string() + "mu_a2");
+    param_names__.push_back(std::string() + "sigma_a1");
+    param_names__.push_back(std::string() + "sigma_a2");
+    param_names__.push_back(std::string() + "sigma_y");
+    if (emit_transformed_parameters__) {
+      for (int sym50__ = 1; sym50__ <= J; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "a1" + '.' + std::to_string(sym50__));
+        }}
+      for (int sym50__ = 1; sym50__ <= J; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "a2" + '.' + std::to_string(sym50__));
+        }}
+      for (int sym50__ = 1; sym50__ <= N; ++sym50__) {
+        {
+          param_names__.push_back(std::string() + "y_hat" + '.' + std::to_string(sym50__));
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"eta1\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"parameters\"},{\"name\":\"eta2\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"parameters\"},{\"name\":\"mu_a1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mu_a2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_a1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_a2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_y\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"a1\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"transformed_parameters\"},{\"name\":\"a2\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"transformed_parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"beta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"eta1\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"parameters\"},{\"name\":\"eta2\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"parameters\"},{\"name\":\"mu_a1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"mu_a2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_a1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_a2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_y\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"a1\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"transformed_parameters\"},{\"name\":\"a2\",\"type\":{\"name\":\"vector\",\"length\":" << J << "},\"block\":\"transformed_parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef off_small_model_namespace::off_small_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp optimizations.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace optimizations_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'optimizations.stan', line 20, column 4 to column 15)",
+                                                      " (in 'optimizations.stan', line 21, column 4 to column 13)",
+                                                      " (in 'optimizations.stan', line 22, column 4 to column 26)",
+                                                      " (in 'optimizations.stan', line 23, column 4 to column 23)",
+                                                      " (in 'optimizations.stan', line 24, column 4 to column 24)",
+                                                      " (in 'optimizations.stan', line 27, column 4 to column 11)",
+                                                      " (in 'optimizations.stan', line 5, column 8 to column 20)",
+                                                      " (in 'optimizations.stan', line 2, column 33 to line 6, column 5)",
+                                                      " (in 'optimizations.stan', line 9, column 8 to line 10, column 26)",
+                                                      " (in 'optimizations.stan', line 8, column 20 to line 12, column 5)",
+                                                      " (in 'optimizations.stan', line 30, column 17 to column 28)",
+                                                      " (in 'optimizations.stan', line 31, column 33 to line 34, column 5)",
+                                                      " (in 'optimizations.stan', line 36, column 8 to column 21)",
+                                                      " (in 'optimizations.stan', line 35, column 4 to line 37, column 5)",
+                                                      " (in 'optimizations.stan', line 41, column 16 to column 29)",
+                                                      " (in 'optimizations.stan', line 40, column 12 to line 41, column 29)",
+                                                      " (in 'optimizations.stan', line 39, column 8 to line 41, column 29)",
+                                                      " (in 'optimizations.stan', line 38, column 4 to line 41, column 29)",
+                                                      " (in 'optimizations.stan', line 44, column 10 to column 16)",
+                                                      " (in 'optimizations.stan', line 43, column 8 to line 44, column 16)",
+                                                      " (in 'optimizations.stan', line 45, column 8 to column 20)",
+                                                      " (in 'optimizations.stan', line 42, column 21 to line 46, column 5)",
+                                                      " (in 'optimizations.stan', line 42, column 4 to line 46, column 5)",
+                                                      " (in 'optimizations.stan', line 49, column 10 to column 19)",
+                                                      " (in 'optimizations.stan', line 48, column 8 to line 49, column 19)",
+                                                      " (in 'optimizations.stan', line 50, column 8 to column 20)",
+                                                      " (in 'optimizations.stan', line 47, column 21 to line 51, column 5)",
+                                                      " (in 'optimizations.stan', line 47, column 4 to line 51, column 5)",
+                                                      " (in 'optimizations.stan', line 54, column 10 to column 19)",
+                                                      " (in 'optimizations.stan', line 53, column 8 to line 54, column 19)",
+                                                      " (in 'optimizations.stan', line 55, column 8 to column 20)",
+                                                      " (in 'optimizations.stan', line 52, column 21 to line 56, column 5)",
+                                                      " (in 'optimizations.stan', line 52, column 4 to line 56, column 5)",
+                                                      " (in 'optimizations.stan', line 57, column 4 to column 10)",
+                                                      " (in 'optimizations.stan', line 58, column 4 to column 16)",
+                                                      " (in 'optimizations.stan', line 60, column 6 to column 12)",
+                                                      " (in 'optimizations.stan', line 59, column 4 to line 60, column 12)",
+                                                      " (in 'optimizations.stan', line 61, column 4 to column 16)",
+                                                      " (in 'optimizations.stan', line 64, column 4 to column 16)",
+                                                      " (in 'optimizations.stan', line 65, column 4 to column 16)",
+                                                      " (in 'optimizations.stan', line 66, column 4 to column 16)",
+                                                      " (in 'optimizations.stan', line 68, column 6 to column 19)",
+                                                      " (in 'optimizations.stan', line 69, column 4 to column 16)",
+                                                      " (in 'optimizations.stan', line 70, column 4 to column 11)",
+                                                      " (in 'optimizations.stan', line 71, column 4 to column 10)",
+                                                      " (in 'optimizations.stan', line 72, column 4 to column 16)",
+                                                      " (in 'optimizations.stan', line 74, column 6 to column 12)",
+                                                      " (in 'optimizations.stan', line 73, column 4 to line 74, column 12)",
+                                                      " (in 'optimizations.stan', line 75, column 4 to column 16)",
+                                                      " (in 'optimizations.stan', line 78, column 4 to column 16)",
+                                                      " (in 'optimizations.stan', line 80, column 8 to column 19)",
+                                                      " (in 'optimizations.stan', line 82, column 8 to column 20)",
+                                                      " (in 'optimizations.stan', line 79, column 4 to line 83, column 5)",
+                                                      " (in 'optimizations.stan', line 85, column 8 to column 20)",
+                                                      " (in 'optimizations.stan', line 87, column 8 to column 20)",
+                                                      " (in 'optimizations.stan', line 84, column 4 to line 88, column 5)",
+                                                      " (in 'optimizations.stan', line 90, column 11 to column 23)",
+                                                      " (in 'optimizations.stan', line 90, column 4 to column 23)",
+                                                      " (in 'optimizations.stan', line 15, column 8 to column 20)",
+                                                      " (in 'optimizations.stan', line 14, column 18 to line 17, column 5)",
+                                                      " (in 'optimizations.stan', line 97, column 20 to column 26)",
+                                                      " (in 'optimizations.stan', line 97, column 4 to column 26)",
+                                                      " (in 'optimizations.stan', line 98, column 22 to column 28)",
+                                                      " (in 'optimizations.stan', line 100, column 6 to column 15)",
+                                                      " (in 'optimizations.stan', line 99, column 4 to line 100, column 15)",
+                                                      " (in 'optimizations.stan', line 102, column 6 to column 12)",
+                                                      " (in 'optimizations.stan', line 101, column 4 to line 102, column 12)",
+                                                      " (in 'optimizations.stan', line 106, column 6 to column 15)",
+                                                      " (in 'optimizations.stan', line 108, column 6 to column 12)",
+                                                      " (in 'optimizations.stan', line 112, column 8 to column 20)",
+                                                      " (in 'optimizations.stan', line 115, column 8 to column 21)",
+                                                      " (in 'optimizations.stan', line 111, column 4 to line 116, column 5)",
+                                                      " (in 'optimizations.stan', line 119, column 12 to column 24)",
+                                                      " (in 'optimizations.stan', line 118, column 8 to line 121, column 9)",
+                                                      " (in 'optimizations.stan', line 117, column 4 to line 127, column 5)",
+                                                      " (in 'optimizations.stan', line 128, column 4 to column 14)",
+                                                      " (in 'optimizations.stan', line 132, column 6 to column 21)",
+                                                      " (in 'optimizations.stan', line 129, column 4 to line 132, column 21)",
+                                                      " (in 'optimizations.stan', line 134, column 4 to column 15)",
+                                                      " (in 'optimizations.stan', line 137, column 8 to column 23)",
+                                                      " (in 'optimizations.stan', line 138, column 8 to column 24)",
+                                                      " (in 'optimizations.stan', line 135, column 4 to line 139, column 5)",
+                                                      " (in 'optimizations.stan', line 140, column 4 to column 25)",
+                                                      " (in 'optimizations.stan', line 143, column 4 to column 26)",
+                                                      " (in 'optimizations.stan', line 144, column 4 to column 22)",
+                                                      " (in 'optimizations.stan', line 146, column 6 to column 28)",
+                                                      " (in 'optimizations.stan', line 145, column 4 to line 146, column 28)",
+                                                      " (in 'optimizations.stan', line 147, column 4 to column 23)",
+                                                      " (in 'optimizations.stan', line 4, column 10 to column 17)",
+                                                      " (in 'optimizations.stan', line 3, column 8 to line 4, column 17)",
+                                                      " (in 'optimizations.stan', line 10, column 12 to column 26)",
+                                                      " (in 'optimizations.stan', line 11, column 8 to column 21)",
+                                                      " (in 'optimizations.stan', line 16, column 8 to column 18)"};
+
+
+template <bool propto__, typename T0__, typename T_lp__,
+typename T_lp_accum__>
+void
+nrfun_lp(const T0__& x, const int& y, T_lp__& lp__, T_lp_accum__& lp_accum__,
+         std::ostream* pstream__) {
+  using local_scalar_t__ = stan::promote_args_t<T0__>;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym35__;
+    {
+      current_statement__ = 90;
+      if (logical_gt(x, 342)) {
+        current_statement__ = 89;
+        return ;
+      } 
+      current_statement__ = 7;
+      lp_accum__.add(y);
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct nrfun_lp_functor__ {
+template <bool propto__, typename T0__, typename T_lp__,
+typename T_lp_accum__>
+void
+operator()(const T0__& x, const int& y, T_lp__& lp__,
+           T_lp_accum__& lp_accum__, std::ostream* pstream__)  const 
+{
+return nrfun_lp(x, y, lp__, lp_accum__, pstream__);
+}
+};
+
+int
+rfun(const int& y, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  const static bool propto__ = true;
+  (void) propto__;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    int lcm_sym38__;
+    int lcm_sym37__;
+    int lcm_sym36__;
+    {
+      current_statement__ = 9;
+      if (logical_gt(y, 2)) {
+        current_statement__ = 91;
+        return (y + 24);
+      } 
+      current_statement__ = 92;
+      return (y + 2);
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct rfun_functor__ {
+int
+operator()(const int& y, std::ostream* pstream__)  const 
+{
+return rfun(y, pstream__);
+}
+};
+
+template <bool propto__, typename T_lp__, typename T_lp_accum__>
+int
+rfun_lp(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__) {
+  using local_scalar_t__ = double;
+  local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+  (void) DUMMY_VAR__;  // suppress unused var warning
+  
+  try {
+    {
+      current_statement__ = 59;
+      lp_accum__.add(2);
+      current_statement__ = 93;
+      return 24;
+    }
+  } catch (const std::exception& e) {
+    stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+  }
+  
+}
+
+struct rfun_lp_functor__ {
+template <bool propto__, typename T_lp__, typename T_lp_accum__>
+int
+operator()(T_lp__& lp__, T_lp_accum__& lp_accum__, std::ostream* pstream__)  const 
+{
+return rfun_lp(lp__, lp_accum__, pstream__);
+}
+};
+
+class optimizations_model : public model_base_crtp<optimizations_model> {
+
+ private:
+  int pos__;
+ 
+ public:
+  ~optimizations_model() { }
+  
+  std::string model_name() const { return "optimizations_model"; }
+  
+  optimizations_model(stan::io::var_context& context__,
+                      unsigned int random_seed__ = 0,
+                      std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "optimizations_model_namespace::optimizations_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      current_statement__ = 3;
+      validate_non_negative_index("x_matrix", "3", 3);
+      current_statement__ = 3;
+      validate_non_negative_index("x_matrix", "2", 2);
+      num_params_r__ += 3 * 2;
+      current_statement__ = 4;
+      validate_non_negative_index("x_vector", "2", 2);
+      num_params_r__ += 2;
+      current_statement__ = 5;
+      validate_non_negative_index("x_cov", "2", 2);
+      current_statement__ = 5;
+      validate_non_negative_index("x_cov", "2", 2);
+      num_params_r__ += 3;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "optimizations_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym79__;
+      int lcm_sym78__;
+      int lcm_sym77__;
+      int lcm_sym76__;
+      int lcm_sym75__;
+      int lcm_sym74__;
+      int lcm_sym73__;
+      int lcm_sym72__;
+      int lcm_sym71__;
+      int lcm_sym70__;
+      int lcm_sym69__;
+      int lcm_sym68__;
+      int lcm_sym67__;
+      int lcm_sym66__;
+      local_scalar_t__ theta;
+      theta = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      theta = in__.scalar();
+      local_scalar_t__ phi;
+      phi = DUMMY_VAR__;
+      
+      current_statement__ = 2;
+      phi = in__.scalar();
+      current_statement__ = 3;
+      validate_non_negative_index("x_matrix", "3", 3);
+      current_statement__ = 3;
+      validate_non_negative_index("x_matrix", "2", 2);
+      Eigen::Matrix<local_scalar_t__, -1, -1> x_matrix;
+      x_matrix = Eigen::Matrix<local_scalar_t__, -1, -1>(3, 2);
+      stan::math::fill(x_matrix, DUMMY_VAR__);
+      
+      current_statement__ = 3;
+      x_matrix = in__.matrix(3, 2);
+      current_statement__ = 4;
+      validate_non_negative_index("x_vector", "2", 2);
+      Eigen::Matrix<local_scalar_t__, -1, 1> x_vector;
+      x_vector = Eigen::Matrix<local_scalar_t__, -1, 1>(2);
+      stan::math::fill(x_vector, DUMMY_VAR__);
+      
+      current_statement__ = 4;
+      x_vector = in__.vector(2);
+      current_statement__ = 5;
+      validate_non_negative_index("x_cov", "2", 2);
+      current_statement__ = 5;
+      validate_non_negative_index("x_cov", "2", 2);
+      Eigen::Matrix<local_scalar_t__, -1, -1> x_cov;
+      x_cov = Eigen::Matrix<local_scalar_t__, -1, -1>(2, 2);
+      stan::math::fill(x_cov, DUMMY_VAR__);
+      
+      Eigen::Matrix<local_scalar_t__, -1, 1> x_cov_in__;
+      x_cov_in__ = Eigen::Matrix<local_scalar_t__, -1, 1>(3);
+      stan::math::fill(x_cov_in__, DUMMY_VAR__);
+      
+      current_statement__ = 5;
+      x_cov_in__ = in__.vector(3);
+      current_statement__ = 5;
+      if (jacobian__) {
+        current_statement__ = 5;
+        assign(x_cov, nil_index_list(),
+          stan::math::cov_matrix_constrain(x_cov_in__, 2, lp__),
+          "assigning variable x_cov");
+      } else {
+        current_statement__ = 5;
+        assign(x_cov, nil_index_list(),
+          stan::math::cov_matrix_constrain(x_cov_in__, 2),
+          "assigning variable x_cov");
+      }
+      {
+        double x;
+        x = std::numeric_limits<double>::quiet_NaN();
+        
+        int inline_sym1__;
+        inline_sym1__ = std::numeric_limits<int>::min();
+        
+        for (int inline_sym2__ = 1; inline_sym2__ <= 1; ++inline_sym2__) {
+          current_statement__ = 7;
+          lp_accum__.add(3);}
+        int inline_sym3__;
+        int inline_sym4__;
+        inline_sym4__ = std::numeric_limits<int>::min();
+        
+        for (int inline_sym5__ = 1; inline_sym5__ <= 1; ++inline_sym5__) {
+          {
+            inline_sym3__ = 27;
+            break;
+          }
+          inline_sym3__ = 5;
+          break;}
+        if (pstream__) {
+          stan_print(pstream__, inline_sym3__);
+          stan_print(pstream__, "\n");
+        }
+        int inline_sym6__;
+        int inline_sym7__;
+        inline_sym7__ = std::numeric_limits<int>::min();
+        
+        for (int inline_sym8__ = 1; inline_sym8__ <= 1; ++inline_sym8__) {
+          {
+            inline_sym6__ = 28;
+            break;
+          }
+          inline_sym6__ = 6;
+          break;}
+        if (inline_sym6__) {
+          current_statement__ = 11;
+          if (pstream__) {
+            stan_print(pstream__, "a");
+            stan_print(pstream__, "\n");
+          }
+        } 
+        int inline_sym9__;
+        int inline_sym12__;
+        int inline_sym10__;
+        inline_sym10__ = std::numeric_limits<int>::min();
+        
+        for (int inline_sym11__ = 1; inline_sym11__ <= 1; ++inline_sym11__) {
+          {
+            inline_sym9__ = 31;
+            break;
+          }
+          inline_sym9__ = 9;
+          break;}
+        int inline_sym13__;
+        inline_sym13__ = std::numeric_limits<int>::min();
+        
+        for (int inline_sym14__ = 1; inline_sym14__ <= 1; ++inline_sym14__) {
+          {
+            inline_sym12__ = 29;
+            break;
+          }
+          inline_sym12__ = 7;
+          break;}
+        if (logical_gte(inline_sym12__, inline_sym9__)) {
+          {
+            int inline_sym15__;
+            int inline_sym16__;
+            inline_sym16__ = std::numeric_limits<int>::min();
+            
+            for (int inline_sym17__ = 1; inline_sym17__ <= 1;
+                 ++inline_sym17__) {
+              {
+                inline_sym15__ = 32;
+                break;
+              }
+              inline_sym15__ = 10;
+              break;}
+            lp_accum__.add(inline_sym15__);
+            int inline_sym18__;
+            inline_sym18__ = std::numeric_limits<int>::min();
+            
+            for (int inline_sym19__ = 1; inline_sym19__ <= 1;
+                 ++inline_sym19__) {
+              current_statement__ = 7;
+              lp_accum__.add(3);}
+          }
+          int inline_sym13__;
+          inline_sym13__ = std::numeric_limits<int>::min();
+          
+          lcm_sym75__ = (inline_sym9__ + 1);
+          for (int inline_sym14__ = 1; inline_sym14__ <= 1; ++inline_sym14__) {
+            {
+              inline_sym12__ = 29;
+              lcm_sym75__ = (inline_sym9__ + 1);
+              break;
+            }
+            inline_sym12__ = 7;
+            lcm_sym75__ = (inline_sym9__ + 1);
+            break;}
+          for (int i = lcm_sym75__; i <= inline_sym12__; ++i) {
+            {
+              int inline_sym15__;
+              int inline_sym16__;
+              inline_sym16__ = std::numeric_limits<int>::min();
+              
+              for (int inline_sym17__ = 1; inline_sym17__ <= 1;
+                   ++inline_sym17__) {
+                {
+                  inline_sym15__ = 32;
+                  break;
+                }
+                inline_sym15__ = 10;
+                break;}
+              lp_accum__.add(inline_sym15__);
+              int inline_sym18__;
+              inline_sym18__ = std::numeric_limits<int>::min();
+              
+              for (int inline_sym19__ = 1; inline_sym19__ <= 1;
+                   ++inline_sym19__) {
+                current_statement__ = 7;
+                lp_accum__.add(3);}
+            }
+            int inline_sym13__;
+            inline_sym13__ = std::numeric_limits<int>::min();
+            
+            for (int inline_sym14__ = 1; inline_sym14__ <= 1;
+                 ++inline_sym14__) {
+              {
+                inline_sym12__ = 29;
+                break;
+              }
+              inline_sym12__ = 7;
+              break;}}
+        } 
+        {
+          current_statement__ = 13;
+          lp_accum__.add(53);
+          {
+            current_statement__ = 13;
+            lp_accum__.add(53);
+          }
+          {
+            current_statement__ = 13;
+            lp_accum__.add(53);
+          }
+          {
+            current_statement__ = 13;
+            lp_accum__.add(53);
+          }
+          {
+            current_statement__ = 13;
+            lp_accum__.add(53);
+          }
+        }
+        {
+          {
+            {
+              current_statement__ = 15;
+              lp_accum__.add(53);
+              {
+                current_statement__ = 15;
+                lp_accum__.add(53);
+              }
+            }
+            {
+              lcm_sym78__ = (2 * 2);
+              if (logical_gte(lcm_sym78__, 2)) {
+                lcm_sym76__ = (2 + 1);
+                lp_accum__.add(53);
+                for (int k = lcm_sym76__; k <= lcm_sym78__; ++k) {
+                  current_statement__ = 15;
+                  lp_accum__.add(53);}
+              } 
+            }
+            {
+              lcm_sym78__ = (3 * 2);
+              if (logical_gte(lcm_sym78__, 3)) {
+                lcm_sym76__ = (3 + 1);
+                lp_accum__.add(53);
+                for (int k = lcm_sym76__; k <= lcm_sym78__; ++k) {
+                  current_statement__ = 15;
+                  lp_accum__.add(53);}
+              } 
+            }
+          }
+          {
+            lcm_sym74__ = (2 + 2);
+            if (logical_gte(lcm_sym74__, 2)) {
+              lcm_sym77__ = (2 * 2);
+              if (logical_gte(lcm_sym77__, 2)) {
+                {
+                  lcm_sym73__ = (2 + 1);
+                  lp_accum__.add(53);
+                  for (int k = lcm_sym73__; k <= lcm_sym77__; ++k) {
+                    current_statement__ = 15;
+                    lp_accum__.add(53);}
+                }
+              } else {
+                lcm_sym73__ = (2 + 1);
+              }
+              for (int j = lcm_sym73__; j <= lcm_sym74__; ++j) {
+                lcm_sym78__ = (j * 2);
+                if (logical_gte(lcm_sym78__, j)) {
+                  lcm_sym76__ = (j + 1);
+                  lp_accum__.add(53);
+                  for (int k = lcm_sym76__; k <= lcm_sym78__; ++k) {
+                    current_statement__ = 15;
+                    lp_accum__.add(53);}
+                } }
+            } 
+          }
+          {
+            lcm_sym74__ = (3 + 2);
+            if (logical_gte(lcm_sym74__, 3)) {
+              lcm_sym77__ = (3 * 2);
+              if (logical_gte(lcm_sym77__, 3)) {
+                {
+                  lcm_sym73__ = (3 + 1);
+                  lp_accum__.add(53);
+                  for (int k = lcm_sym73__; k <= lcm_sym77__; ++k) {
+                    current_statement__ = 15;
+                    lp_accum__.add(53);}
+                }
+              } else {
+                lcm_sym73__ = (3 + 1);
+              }
+              for (int j = lcm_sym73__; j <= lcm_sym74__; ++j) {
+                lcm_sym78__ = (j * 2);
+                if (logical_gte(lcm_sym78__, j)) {
+                  lcm_sym76__ = (j + 1);
+                  lp_accum__.add(53);
+                  for (int k = lcm_sym76__; k <= lcm_sym78__; ++k) {
+                    current_statement__ = 15;
+                    lp_accum__.add(53);}
+                } }
+            } 
+          }
+          {
+            lcm_sym74__ = (4 + 2);
+            if (logical_gte(lcm_sym74__, 4)) {
+              lcm_sym77__ = (4 * 2);
+              if (logical_gte(lcm_sym77__, 4)) {
+                {
+                  lcm_sym73__ = (4 + 1);
+                  lp_accum__.add(53);
+                  for (int k = lcm_sym73__; k <= lcm_sym77__; ++k) {
+                    current_statement__ = 15;
+                    lp_accum__.add(53);}
+                }
+              } else {
+                lcm_sym73__ = (4 + 1);
+              }
+              for (int j = lcm_sym73__; j <= lcm_sym74__; ++j) {
+                lcm_sym78__ = (j * 2);
+                if (logical_gte(lcm_sym78__, j)) {
+                  lcm_sym76__ = (j + 1);
+                  lp_accum__.add(53);
+                  for (int k = lcm_sym76__; k <= lcm_sym78__; ++k) {
+                    current_statement__ = 15;
+                    lp_accum__.add(53);}
+                } }
+            } 
+          }
+          {
+            lcm_sym74__ = (5 + 2);
+            if (logical_gte(lcm_sym74__, 5)) {
+              lcm_sym77__ = (5 * 2);
+              if (logical_gte(lcm_sym77__, 5)) {
+                {
+                  lcm_sym73__ = (5 + 1);
+                  lp_accum__.add(53);
+                  for (int k = lcm_sym73__; k <= lcm_sym77__; ++k) {
+                    current_statement__ = 15;
+                    lp_accum__.add(53);}
+                }
+              } else {
+                lcm_sym73__ = (5 + 1);
+              }
+              for (int j = lcm_sym73__; j <= lcm_sym74__; ++j) {
+                lcm_sym78__ = (j * 2);
+                if (logical_gte(lcm_sym78__, j)) {
+                  lcm_sym76__ = (j + 1);
+                  lp_accum__.add(53);
+                  for (int k = lcm_sym76__; k <= lcm_sym78__; ++k) {
+                    current_statement__ = 15;
+                    lp_accum__.add(53);}
+                } }
+            } 
+          }
+        }
+        current_statement__ = 23;
+        for (int i = 1; i <= 5; ++i) {
+          current_statement__ = 20;
+          if (logical_gt(i, 4)) {
+            break;
+          } 
+          current_statement__ = 21;
+          lp_accum__.add(2);}
+        current_statement__ = 28;
+        for (int i = 1; i <= 5; ++i) {
+          current_statement__ = 25;
+          if (logical_gt(i, 4)) {
+            continue;
+          } 
+          current_statement__ = 26;
+          lp_accum__.add(2);}
+        current_statement__ = 33;
+        for (int i = 1; i <= 5; ++i) {
+          current_statement__ = 30;
+          if (logical_gt(i, 4)) {
+            continue;
+          } 
+          current_statement__ = 31;
+          lp_accum__.add(2);}
+        current_statement__ = 34;
+        x = 3;
+        current_statement__ = 35;
+        lp_accum__.add(3);
+        current_statement__ = 37;
+        if (logical_gt(theta, 2)) {
+          current_statement__ = 36;
+          x = 2;
+        } 
+        current_statement__ = 38;
+        lp_accum__.add(x);
+        current_statement__ = 39;
+        lp_accum__.add(247);
+        current_statement__ = 40;
+        x = 576;
+        current_statement__ = 41;
+        lp_accum__.add(576);
+        lcm_sym72__ = logical_gt(theta, 46);
+        if (lcm_sym72__) {
+          current_statement__ = 42;
+          x = 5880;
+        } 
+        current_statement__ = 43;
+        lp_accum__.add(x);
+        double z;
+        z = std::numeric_limits<double>::quiet_NaN();
+        
+        current_statement__ = 45;
+        z = x;
+        current_statement__ = 46;
+        lp_accum__.add(x);
+        current_statement__ = 48;
+        if (lcm_sym72__) {
+          current_statement__ = 47;
+          z = x;
+        } 
+        current_statement__ = 49;
+        lp_accum__.add(z);
+        current_statement__ = 50;
+        lp_accum__.add(2);
+        {
+          double y;
+          y = std::numeric_limits<double>::quiet_NaN();
+          
+          current_statement__ = 52;
+          lp_accum__.add(24);
+        }
+        {
+          double y;
+          y = std::numeric_limits<double>::quiet_NaN();
+          
+          current_statement__ = 55;
+          lp_accum__.add(245);
+        }
+        {
+          current_statement__ = 57;
+          lp_accum__.add(2);
+        }
+        int inline_sym20__;
+        int inline_sym21__;
+        inline_sym21__ = std::numeric_limits<int>::min();
+        
+        for (int inline_sym22__ = 1; inline_sym22__ <= 1; ++inline_sym22__) {
+          current_statement__ = 59;
+          lp_accum__.add(2);
+          break;}
+        current_statement__ = 62;
+        while (576) {
+          break;
+        }
+        int inline_sym23__;
+        int inline_sym24__;
+        inline_sym24__ = std::numeric_limits<int>::min();
+        
+        for (int inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) {
+          current_statement__ = 59;
+          lp_accum__.add(2);
+          inline_sym23__ = 24;
+          break;}
+        while (inline_sym23__) {
+          {
+            break;
+          }
+          int inline_sym24__;
+          inline_sym24__ = std::numeric_limits<int>::min();
+          
+          for (int inline_sym25__ = 1; inline_sym25__ <= 1; ++inline_sym25__) {
+            current_statement__ = 59;
+            lp_accum__.add(2);
+            inline_sym23__ = 24;
+            break;}
+        }
+        current_statement__ = 65;
+        for (int i = 31; i <= 225; ++i) { continue;}
+        current_statement__ = 67;
+        for (int i = 31; i <= 225; ++i) { break;}
+        int inline_sym26__;
+        int inline_sym27__;
+        inline_sym27__ = std::numeric_limits<int>::min();
+        
+        for (int inline_sym28__ = 1; inline_sym28__ <= 1; ++inline_sym28__) {
+          current_statement__ = 59;
+          lp_accum__.add(2);
+          inline_sym26__ = 24;
+          break;}
+        for (int i = inline_sym26__; i <= 225; ++i) { continue;}
+        int inline_sym29__;
+        int inline_sym30__;
+        inline_sym30__ = std::numeric_limits<int>::min();
+        
+        for (int inline_sym31__ = 1; inline_sym31__ <= 1; ++inline_sym31__) {
+          current_statement__ = 59;
+          lp_accum__.add(2);
+          inline_sym29__ = 24;
+          break;}
+        for (int i = inline_sym29__; i <= 225; ++i) { break;}
+        int inline_sym32__;
+        int inline_sym33__;
+        inline_sym33__ = std::numeric_limits<int>::min();
+        
+        for (int inline_sym34__ = 1; inline_sym34__ <= 1; ++inline_sym34__) {
+          current_statement__ = 59;
+          lp_accum__.add(2);
+          break;}
+        {
+          current_statement__ = 70;
+          lp_accum__.add(1);
+          current_statement__ = 71;
+          lp_accum__.add(24);
+        }
+        {
+          {
+            current_statement__ = 73;
+            lp_accum__.add(1);
+          }
+        }
+        double temp;
+        temp = std::numeric_limits<double>::quiet_NaN();
+        
+        {
+          current_statement__ = 77;
+          if (pstream__) {
+            stan_print(pstream__, "hello");
+            stan_print(pstream__, "\n");
+          }
+        }
+        double temp2;
+        temp2 = std::numeric_limits<double>::quiet_NaN();
+        
+        {
+          current_statement__ = 80;
+          lp_accum__.add(4);
+          current_statement__ = 81;
+          lp_accum__.add(6);
+          {
+            current_statement__ = 80;
+            lp_accum__.add(4);
+            current_statement__ = 81;
+            lp_accum__.add(6);
+          }
+        }
+        double dataonlyvar;
+        dataonlyvar = std::numeric_limits<double>::quiet_NaN();
+        
+        current_statement__ = 83;
+        dataonlyvar = 3;
+        current_statement__ = 84;
+        lp_accum__.add(dataonlyvar);
+        local_scalar_t__ paramvar;
+        paramvar = DUMMY_VAR__;
+        
+        {
+          current_statement__ = 86;
+          paramvar = (theta * 34);
+        }
+        current_statement__ = 88;
+        lp_accum__.add(paramvar);
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "optimizations_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym65__;
+      double lcm_sym64__;
+      double lcm_sym63__;
+      double lcm_sym62__;
+      double lcm_sym61__;
+      double lcm_sym60__;
+      double lcm_sym59__;
+      double lcm_sym58__;
+      double lcm_sym57__;
+      double lcm_sym56__;
+      int lcm_sym55__;
+      int lcm_sym54__;
+      double theta;
+      theta = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      theta = in__.scalar();
+      double phi;
+      phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      phi = in__.scalar();
+      current_statement__ = 3;
+      validate_non_negative_index("x_matrix", "3", 3);
+      current_statement__ = 3;
+      validate_non_negative_index("x_matrix", "2", 2);
+      Eigen::Matrix<double, -1, -1> x_matrix;
+      x_matrix = Eigen::Matrix<double, -1, -1>(3, 2);
+      stan::math::fill(x_matrix, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 3;
+      x_matrix = in__.matrix(3, 2);
+      current_statement__ = 4;
+      validate_non_negative_index("x_vector", "2", 2);
+      Eigen::Matrix<double, -1, 1> x_vector;
+      x_vector = Eigen::Matrix<double, -1, 1>(2);
+      stan::math::fill(x_vector, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 4;
+      x_vector = in__.vector(2);
+      current_statement__ = 5;
+      validate_non_negative_index("x_cov", "2", 2);
+      current_statement__ = 5;
+      validate_non_negative_index("x_cov", "2", 2);
+      Eigen::Matrix<double, -1, -1> x_cov;
+      x_cov = Eigen::Matrix<double, -1, -1>(2, 2);
+      stan::math::fill(x_cov, std::numeric_limits<double>::quiet_NaN());
+      
+      Eigen::Matrix<double, -1, 1> x_cov_in__;
+      x_cov_in__ = Eigen::Matrix<double, -1, 1>(3);
+      stan::math::fill(x_cov_in__, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 5;
+      x_cov_in__ = in__.vector(3);
+      current_statement__ = 5;
+      assign(x_cov, nil_index_list(),
+        stan::math::cov_matrix_constrain(x_cov_in__, 2),
+        "assigning variable x_cov");
+      vars__.push_back(theta);
+      vars__.push_back(phi);
+      {
+        {
+          vars__.push_back(
+            rvalue(x_matrix,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "x_matrix"));
+          {
+            vars__.push_back(
+              rvalue(x_matrix,
+                cons_list(index_uni(2),
+                  cons_list(index_uni(1), nil_index_list())), "x_matrix"));
+          }
+          {
+            vars__.push_back(
+              rvalue(x_matrix,
+                cons_list(index_uni(3),
+                  cons_list(index_uni(1), nil_index_list())), "x_matrix"));
+          }
+        }
+        {
+          {
+            vars__.push_back(
+              rvalue(x_matrix,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(2), nil_index_list())), "x_matrix"));
+            {
+              vars__.push_back(
+                rvalue(x_matrix,
+                  cons_list(index_uni(2),
+                    cons_list(index_uni(2), nil_index_list())), "x_matrix"));
+            }
+            {
+              vars__.push_back(
+                rvalue(x_matrix,
+                  cons_list(index_uni(3),
+                    cons_list(index_uni(2), nil_index_list())), "x_matrix"));
+            }
+          }
+        }
+      }
+      {
+        vars__.push_back(
+          rvalue(x_vector, cons_list(index_uni(1), nil_index_list()),
+            "x_vector"));
+        {
+          vars__.push_back(
+            rvalue(x_vector, cons_list(index_uni(2), nil_index_list()),
+              "x_vector"));
+        }
+      }
+      {
+        {
+          vars__.push_back(
+            rvalue(x_cov,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "x_cov"));
+          {
+            vars__.push_back(
+              rvalue(x_cov,
+                cons_list(index_uni(2),
+                  cons_list(index_uni(1), nil_index_list())), "x_cov"));
+          }
+        }
+        {
+          {
+            vars__.push_back(
+              rvalue(x_cov,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(2), nil_index_list())), "x_cov"));
+            {
+              vars__.push_back(
+                rvalue(x_cov,
+                  cons_list(index_uni(2),
+                    cons_list(index_uni(2), nil_index_list())), "x_cov"));
+            }
+          }
+        }
+      }
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym53__;
+      double lcm_sym52__;
+      double lcm_sym51__;
+      double lcm_sym50__;
+      double lcm_sym49__;
+      double lcm_sym48__;
+      double lcm_sym47__;
+      double lcm_sym46__;
+      double lcm_sym45__;
+      double lcm_sym44__;
+      double lcm_sym43__;
+      double lcm_sym42__;
+      double lcm_sym41__;
+      double lcm_sym40__;
+      int lcm_sym39__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      double theta;
+      theta = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      theta = context__.vals_r("theta")[(1 - 1)];
+      double phi;
+      phi = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      phi = context__.vals_r("phi")[(1 - 1)];
+      current_statement__ = 3;
+      validate_non_negative_index("x_matrix", "3", 3);
+      current_statement__ = 3;
+      validate_non_negative_index("x_matrix", "2", 2);
+      Eigen::Matrix<double, -1, -1> x_matrix;
+      x_matrix = Eigen::Matrix<double, -1, -1>(3, 2);
+      stan::math::fill(x_matrix, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> x_matrix_flat__;
+        current_statement__ = 3;
+        assign(x_matrix_flat__, nil_index_list(),
+          context__.vals_r("x_matrix"), "assigning variable x_matrix_flat__");
+        current_statement__ = 3;
+        pos__ = 1;
+        {
+          {
+            current_statement__ = 3;
+            assign(x_matrix,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())),
+              rvalue(x_matrix_flat__,
+                cons_list(index_uni(1), nil_index_list()), "x_matrix_flat__"),
+              "assigning variable x_matrix");
+            current_statement__ = 3;
+            pos__ = 2;
+            {
+              current_statement__ = 3;
+              assign(x_matrix,
+                cons_list(index_uni(2),
+                  cons_list(index_uni(1), nil_index_list())),
+                x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix");
+              current_statement__ = 3;
+              pos__ = (pos__ + 1);
+            }
+            {
+              current_statement__ = 3;
+              assign(x_matrix,
+                cons_list(index_uni(3),
+                  cons_list(index_uni(1), nil_index_list())),
+                x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix");
+              current_statement__ = 3;
+              pos__ = (pos__ + 1);
+            }
+          }
+          {
+            {
+              current_statement__ = 3;
+              assign(x_matrix,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(2), nil_index_list())),
+                x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix");
+              current_statement__ = 3;
+              pos__ = (pos__ + 1);
+              {
+                current_statement__ = 3;
+                assign(x_matrix,
+                  cons_list(index_uni(2),
+                    cons_list(index_uni(2), nil_index_list())),
+                  x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix");
+                current_statement__ = 3;
+                pos__ = (pos__ + 1);
+              }
+              {
+                current_statement__ = 3;
+                assign(x_matrix,
+                  cons_list(index_uni(3),
+                    cons_list(index_uni(2), nil_index_list())),
+                  x_matrix_flat__[(pos__ - 1)], "assigning variable x_matrix");
+                current_statement__ = 3;
+                pos__ = (pos__ + 1);
+              }
+            }
+          }
+        }
+      }
+      current_statement__ = 4;
+      validate_non_negative_index("x_vector", "2", 2);
+      Eigen::Matrix<double, -1, 1> x_vector;
+      x_vector = Eigen::Matrix<double, -1, 1>(2);
+      stan::math::fill(x_vector, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> x_vector_flat__;
+        current_statement__ = 4;
+        assign(x_vector_flat__, nil_index_list(),
+          context__.vals_r("x_vector"), "assigning variable x_vector_flat__");
+        current_statement__ = 4;
+        pos__ = 1;
+        {
+          current_statement__ = 4;
+          assign(x_vector, cons_list(index_uni(1), nil_index_list()),
+            rvalue(x_vector_flat__,
+              cons_list(index_uni(1), nil_index_list()), "x_vector_flat__"),
+            "assigning variable x_vector");
+          current_statement__ = 4;
+          pos__ = 2;
+          {
+            current_statement__ = 4;
+            assign(x_vector, cons_list(index_uni(2), nil_index_list()),
+              x_vector_flat__[(pos__ - 1)], "assigning variable x_vector");
+            current_statement__ = 4;
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      current_statement__ = 5;
+      validate_non_negative_index("x_cov", "2", 2);
+      current_statement__ = 5;
+      validate_non_negative_index("x_cov", "2", 2);
+      Eigen::Matrix<double, -1, -1> x_cov;
+      x_cov = Eigen::Matrix<double, -1, -1>(2, 2);
+      stan::math::fill(x_cov, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> x_cov_flat__;
+        current_statement__ = 5;
+        assign(x_cov_flat__, nil_index_list(), context__.vals_r("x_cov"),
+          "assigning variable x_cov_flat__");
+        current_statement__ = 5;
+        pos__ = 1;
+        {
+          {
+            current_statement__ = 5;
+            assign(x_cov,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())),
+              rvalue(x_cov_flat__, cons_list(index_uni(1), nil_index_list()),
+                "x_cov_flat__"), "assigning variable x_cov");
+            current_statement__ = 5;
+            pos__ = 2;
+            {
+              current_statement__ = 5;
+              assign(x_cov,
+                cons_list(index_uni(2),
+                  cons_list(index_uni(1), nil_index_list())),
+                x_cov_flat__[(pos__ - 1)], "assigning variable x_cov");
+              current_statement__ = 5;
+              pos__ = (pos__ + 1);
+            }
+          }
+          {
+            {
+              current_statement__ = 5;
+              assign(x_cov,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(2), nil_index_list())),
+                x_cov_flat__[(pos__ - 1)], "assigning variable x_cov");
+              current_statement__ = 5;
+              pos__ = (pos__ + 1);
+              {
+                current_statement__ = 5;
+                assign(x_cov,
+                  cons_list(index_uni(2),
+                    cons_list(index_uni(2), nil_index_list())),
+                  x_cov_flat__[(pos__ - 1)], "assigning variable x_cov");
+                current_statement__ = 5;
+                pos__ = (pos__ + 1);
+              }
+            }
+          }
+        }
+      }
+      current_statement__ = 5;
+      validate_non_negative_index("x_cov_free__",
+                                  "(2 + ((2 * (2 - 1)) / 2))", 3);
+      Eigen::Matrix<double, -1, 1> x_cov_free__;
+      x_cov_free__ = Eigen::Matrix<double, -1, 1>(3);
+      stan::math::fill(x_cov_free__, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 5;
+      assign(x_cov_free__, nil_index_list(),
+        stan::math::cov_matrix_free(x_cov), "assigning variable x_cov_free__");
+      vars__.push_back(theta);
+      vars__.push_back(phi);
+      {
+        {
+          vars__.push_back(
+            rvalue(x_matrix,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "x_matrix"));
+          {
+            vars__.push_back(
+              rvalue(x_matrix,
+                cons_list(index_uni(2),
+                  cons_list(index_uni(1), nil_index_list())), "x_matrix"));
+          }
+          {
+            vars__.push_back(
+              rvalue(x_matrix,
+                cons_list(index_uni(3),
+                  cons_list(index_uni(1), nil_index_list())), "x_matrix"));
+          }
+        }
+        {
+          {
+            vars__.push_back(
+              rvalue(x_matrix,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(2), nil_index_list())), "x_matrix"));
+            {
+              vars__.push_back(
+                rvalue(x_matrix,
+                  cons_list(index_uni(2),
+                    cons_list(index_uni(2), nil_index_list())), "x_matrix"));
+            }
+            {
+              vars__.push_back(
+                rvalue(x_matrix,
+                  cons_list(index_uni(3),
+                    cons_list(index_uni(2), nil_index_list())), "x_matrix"));
+            }
+          }
+        }
+      }
+      {
+        vars__.push_back(
+          rvalue(x_vector, cons_list(index_uni(1), nil_index_list()),
+            "x_vector"));
+        {
+          vars__.push_back(
+            rvalue(x_vector, cons_list(index_uni(2), nil_index_list()),
+              "x_vector"));
+        }
+      }
+      {
+        vars__.push_back(
+          rvalue(x_cov_free__, cons_list(index_uni(1), nil_index_list()),
+            "x_cov_free__"));
+        {
+          vars__.push_back(
+            rvalue(x_cov_free__, cons_list(index_uni(2), nil_index_list()),
+              "x_cov_free__"));
+        }
+        {
+          vars__.push_back(
+            rvalue(x_cov_free__, cons_list(index_uni(3), nil_index_list()),
+              "x_cov_free__"));
+        }
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("theta");
+    names__.push_back("phi");
+    names__.push_back("x_matrix");
+    names__.push_back("x_vector");
+    names__.push_back("x_cov");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(3);
+    
+    dims__.push_back(2);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(2);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(2);
+    
+    dims__.push_back(2);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "theta");
+    param_names__.push_back(std::string() + "phi");
+    for (int sym80__ = 1; sym80__ <= 2; ++sym80__) {
+      {
+        for (int sym81__ = 1; sym81__ <= 3; ++sym81__) {
+          {
+            param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym81__) + '.' + std::to_string(sym80__));
+          }}
+      }}
+    for (int sym80__ = 1; sym80__ <= 2; ++sym80__) {
+      {
+        param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym80__));
+      }}
+    for (int sym80__ = 1; sym80__ <= 2; ++sym80__) {
+      {
+        for (int sym81__ = 1; sym81__ <= 2; ++sym81__) {
+          {
+            param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym81__) + '.' + std::to_string(sym80__));
+          }}
+      }}
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    param_names__.push_back(std::string() + "theta");
+    param_names__.push_back(std::string() + "phi");
+    for (int sym80__ = 1; sym80__ <= 2; ++sym80__) {
+      {
+        for (int sym81__ = 1; sym81__ <= 3; ++sym81__) {
+          {
+            param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym81__) + '.' + std::to_string(sym80__));
+          }}
+      }}
+    for (int sym80__ = 1; sym80__ <= 2; ++sym80__) {
+      {
+        param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym80__));
+      }}
+    for (int sym80__ = 1; sym80__ <= 3; ++sym80__) {
+      {
+        param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym80__));
+      }}
+    if (emit_transformed_parameters__) {
+      
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"x_matrix\",\"type\":{\"name\":\"matrix\",\"rows\":" << 3 << ",\"cols\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_vector\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_cov\",\"type\":{\"name\":\"matrix\",\"rows\":" << 2 << ",\"cols\":" << 2 << "},\"block\":\"parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"x_matrix\",\"type\":{\"name\":\"matrix\",\"rows\":" << 3 << ",\"cols\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_vector\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_cov\",\"type\":{\"name\":\"vector\",\"length\":" << 3 << "},\"block\":\"parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef optimizations_model_namespace::optimizations_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp partial-eval.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace partial_eval_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'partial-eval.stan', line 10, column 2 to column 19)",
+                                                      " (in 'partial-eval.stan', line 11, column 2 to column 17)",
+                                                      " (in 'partial-eval.stan', line 12, column 2 to column 12)",
+                                                      " (in 'partial-eval.stan', line 13, column 2 to column 34)",
+                                                      " (in 'partial-eval.stan', line 14, column 2 to column 34)",
+                                                      " (in 'partial-eval.stan', line 17, column 2 to column 18)",
+                                                      " (in 'partial-eval.stan', line 20, column 4 to line 21, column 42)",
+                                                      " (in 'partial-eval.stan', line 19, column 2 to line 21, column 42)",
+                                                      " (in 'partial-eval.stan', line 24, column 2 to column 22)",
+                                                      " (in 'partial-eval.stan', line 25, column 2 to column 34)",
+                                                      " (in 'partial-eval.stan', line 26, column 2 to column 24)",
+                                                      " (in 'partial-eval.stan', line 27, column 2 to column 29)",
+                                                      " (in 'partial-eval.stan', line 2, column 2 to column 17)",
+                                                      " (in 'partial-eval.stan', line 3, column 2 to column 22)",
+                                                      " (in 'partial-eval.stan', line 4, column 2 to column 36)",
+                                                      " (in 'partial-eval.stan', line 5, column 2 to column 21)",
+                                                      " (in 'partial-eval.stan', line 6, column 2 to column 39)",
+                                                      " (in 'partial-eval.stan', line 7, column 2 to column 14)"};
+
+
+
+class partial_eval_model : 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 lcm_sym31__;
+  int lcm_sym30__;
+  int pos__;
+  int N;
+  int n_pair;
+  std::vector<int> pair;
+  Eigen::Matrix<double, -1, 1> pre_test;
+  Eigen::Matrix<double, -1, 1> treatment;
+  Eigen::Matrix<double, -1, 1> y;
+ 
+ public:
+  ~partial_eval_model() { }
+  
+  std::string model_name() const { return "partial_eval_model"; }
+  
+  partial_eval_model(stan::io::var_context& context__,
+                     unsigned int random_seed__ = 0,
+                     std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "partial_eval_model_namespace::partial_eval_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","N","int",
+          context__.to_vec());
+      N = std::numeric_limits<int>::min();
+      
+      current_statement__ = 13;
+      N = context__.vals_i("N")[(1 - 1)];
+      context__.validate_dims("data initialization","n_pair","int",
+          context__.to_vec());
+      n_pair = std::numeric_limits<int>::min();
+      
+      current_statement__ = 14;
+      n_pair = context__.vals_i("n_pair")[(1 - 1)];
+      current_statement__ = 15;
+      validate_non_negative_index("pair", "N", N);
+      context__.validate_dims("data initialization","pair","int",
+          context__.to_vec(N));
+      pair = std::vector<int>(N, std::numeric_limits<int>::min());
+      
+      current_statement__ = 15;
+      assign(pair, nil_index_list(), context__.vals_i("pair"),
+        "assigning variable pair");
+      current_statement__ = 16;
+      validate_non_negative_index("pre_test", "N", N);
+      context__.validate_dims("data initialization","pre_test","double",
+          context__.to_vec(N));
+      pre_test = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(pre_test, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> pre_test_flat__;
+        current_statement__ = 16;
+        assign(pre_test_flat__, nil_index_list(),
+          context__.vals_r("pre_test"), "assigning variable pre_test_flat__");
+        current_statement__ = 16;
+        pos__ = 1;
+        lcm_sym30__ = logical_gte(N, 1);
+        if (lcm_sym30__) {
+          current_statement__ = 16;
+          assign(pre_test, cons_list(index_uni(1), nil_index_list()),
+            rvalue(pre_test_flat__,
+              cons_list(index_uni(1), nil_index_list()), "pre_test_flat__"),
+            "assigning variable pre_test");
+          current_statement__ = 16;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 16;
+            assign(pre_test, cons_list(index_uni(sym1__), nil_index_list()),
+              pre_test_flat__[(pos__ - 1)], "assigning variable pre_test");
+            current_statement__ = 16;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 17;
+      validate_non_negative_index("treatment", "N", N);
+      context__.validate_dims("data initialization","treatment","double",
+          context__.to_vec(N));
+      treatment = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(treatment, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> treatment_flat__;
+        current_statement__ = 17;
+        assign(treatment_flat__, nil_index_list(),
+          context__.vals_r("treatment"),
+          "assigning variable treatment_flat__");
+        current_statement__ = 17;
+        pos__ = 1;
+        current_statement__ = 17;
+        if (lcm_sym30__) {
+          current_statement__ = 17;
+          assign(treatment, cons_list(index_uni(1), nil_index_list()),
+            rvalue(treatment_flat__,
+              cons_list(index_uni(1), nil_index_list()), "treatment_flat__"),
+            "assigning variable treatment");
+          current_statement__ = 17;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 17;
+            assign(treatment, cons_list(index_uni(sym1__), nil_index_list()),
+              treatment_flat__[(pos__ - 1)], "assigning variable treatment");
+            current_statement__ = 17;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 18;
+      validate_non_negative_index("y", "N", N);
+      context__.validate_dims("data initialization","y","double",
+          context__.to_vec(N));
+      y = Eigen::Matrix<double, -1, 1>(N);
+      stan::math::fill(y, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> y_flat__;
+        current_statement__ = 18;
+        assign(y_flat__, nil_index_list(), context__.vals_r("y"),
+          "assigning variable y_flat__");
+        current_statement__ = 18;
+        pos__ = 1;
+        current_statement__ = 18;
+        if (lcm_sym30__) {
+          current_statement__ = 18;
+          assign(y, cons_list(index_uni(1), nil_index_list()),
+            rvalue(y_flat__, cons_list(index_uni(1), nil_index_list()),
+              "y_flat__"), "assigning variable y");
+          current_statement__ = 18;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+            current_statement__ = 18;
+            assign(y, cons_list(index_uni(sym1__), nil_index_list()),
+              y_flat__[(pos__ - 1)], "assigning variable y");
+            current_statement__ = 18;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 13;
+      current_statement__ = 13;
+      check_greater_or_equal(function__, "N", N, 0);
+      current_statement__ = 14;
+      current_statement__ = 14;
+      check_greater_or_equal(function__, "n_pair", n_pair, 0);
+      current_statement__ = 15;
+      if (lcm_sym30__) {
+        current_statement__ = 15;
+        current_statement__ = 15;
+        check_greater_or_equal(function__, "pair[sym1__]",
+                               rvalue(pair,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "pair"), 1);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 15;
+          current_statement__ = 15;
+          check_greater_or_equal(function__, "pair[sym1__]",
+                                 pair[(sym1__ - 1)], 1);}
+      } 
+      current_statement__ = 15;
+      if (lcm_sym30__) {
+        current_statement__ = 15;
+        current_statement__ = 15;
+        check_less_or_equal(function__, "pair[sym1__]",
+                            rvalue(pair,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "pair"), n_pair);
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          current_statement__ = 15;
+          current_statement__ = 15;
+          check_less_or_equal(function__, "pair[sym1__]", pair[(sym1__ - 1)],
+                              n_pair);}
+      } 
+      current_statement__ = 17;
+      current_statement__ = 17;
+      check_greater_or_equal(function__, "treatment", treatment, 0);
+      current_statement__ = 17;
+      current_statement__ = 17;
+      check_less_or_equal(function__, "treatment", treatment, 1);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      current_statement__ = 1;
+      validate_non_negative_index("a", "n_pair", n_pair);
+      num_params_r__ += n_pair;
+      current_statement__ = 2;
+      validate_non_negative_index("beta", "2", 2);
+      num_params_r__ += 2;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "partial_eval_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym29__;
+      double lcm_sym28__;
+      double lcm_sym27__;
+      double lcm_sym26__;
+      double lcm_sym25__;
+      double lcm_sym24__;
+      int lcm_sym23__;
+      current_statement__ = 1;
+      validate_non_negative_index("a", "n_pair", n_pair);
+      Eigen::Matrix<local_scalar_t__, -1, 1> a;
+      a = Eigen::Matrix<local_scalar_t__, -1, 1>(n_pair);
+      stan::math::fill(a, DUMMY_VAR__);
+      
+      current_statement__ = 1;
+      a = in__.vector(n_pair);
+      current_statement__ = 2;
+      validate_non_negative_index("beta", "2", 2);
+      Eigen::Matrix<local_scalar_t__, -1, 1> beta;
+      beta = Eigen::Matrix<local_scalar_t__, -1, 1>(2);
+      stan::math::fill(beta, DUMMY_VAR__);
+      
+      current_statement__ = 2;
+      beta = in__.vector(2);
+      local_scalar_t__ mu_a;
+      mu_a = DUMMY_VAR__;
+      
+      current_statement__ = 3;
+      mu_a = in__.scalar();
+      local_scalar_t__ sigma_a;
+      sigma_a = DUMMY_VAR__;
+      
+      current_statement__ = 4;
+      sigma_a = in__.scalar();
+      current_statement__ = 4;
+      if (jacobian__) {
+        current_statement__ = 4;
+        sigma_a = stan::math::lub_constrain(sigma_a, 0, 100, lp__);
+      } else {
+        current_statement__ = 4;
+        sigma_a = stan::math::lub_constrain(sigma_a, 0, 100);
+      }
+      local_scalar_t__ sigma_y;
+      sigma_y = DUMMY_VAR__;
+      
+      current_statement__ = 5;
+      sigma_y = in__.scalar();
+      current_statement__ = 5;
+      if (jacobian__) {
+        current_statement__ = 5;
+        sigma_y = stan::math::lub_constrain(sigma_y, 0, 100, lp__);
+      } else {
+        current_statement__ = 5;
+        sigma_y = stan::math::lub_constrain(sigma_y, 0, 100);
+      }
+      current_statement__ = 6;
+      validate_non_negative_index("y_hat", "N", N);
+      Eigen::Matrix<local_scalar_t__, -1, 1> y_hat;
+      y_hat = Eigen::Matrix<local_scalar_t__, -1, 1>(N);
+      stan::math::fill(y_hat, DUMMY_VAR__);
+      
+      current_statement__ = 8;
+      if (logical_gte(N, 1)) {
+        current_statement__ = 7;
+        assign(y_hat, cons_list(index_uni(1), nil_index_list()),
+          stan::math::fma(
+            rvalue(beta, cons_list(index_uni(2), nil_index_list()), "beta"),
+            rvalue(pre_test, cons_list(index_uni(1), nil_index_list()),
+              "pre_test"),
+            stan::math::fma(
+              rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+              rvalue(treatment, cons_list(index_uni(1), nil_index_list()),
+                "treatment"),
+              rvalue(a,
+                cons_list(
+                  index_uni(rvalue(pair,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "pair")), nil_index_list()), "a"))),
+          "assigning variable y_hat");
+        for (int i = 2; i <= N; ++i) {
+          current_statement__ = 7;
+          assign(y_hat, cons_list(index_uni(i), nil_index_list()),
+            stan::math::fma(
+              rvalue(beta, cons_list(index_uni(2), nil_index_list()), "beta"),
+              rvalue(pre_test, cons_list(index_uni(i), nil_index_list()),
+                "pre_test"),
+              stan::math::fma(
+                rvalue(beta, cons_list(index_uni(1), nil_index_list()),
+                  "beta"),
+                rvalue(treatment, cons_list(index_uni(i), nil_index_list()),
+                  "treatment"),
+                rvalue(a,
+                  cons_list(
+                    index_uni(rvalue(pair,
+                                cons_list(index_uni(i), nil_index_list()),
+                                "pair")), nil_index_list()), "a"))),
+            "assigning variable y_hat");}
+      } 
+      {
+        current_statement__ = 9;
+        lp_accum__.add(normal_log<propto__>(mu_a, 0, 1));
+        current_statement__ = 10;
+        lp_accum__.add(normal_log<propto__>(a, (100 * mu_a), sigma_a));
+        current_statement__ = 11;
+        lp_accum__.add(normal_log<propto__>(beta, 0, 100));
+        current_statement__ = 12;
+        lp_accum__.add(normal_log<propto__>(y, y_hat, sigma_y));
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "partial_eval_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym22__;
+      double lcm_sym21__;
+      double lcm_sym20__;
+      double lcm_sym19__;
+      double lcm_sym18__;
+      double lcm_sym17__;
+      double lcm_sym16__;
+      double lcm_sym15__;
+      int lcm_sym14__;
+      int lcm_sym13__;
+      int lcm_sym12__;
+      int lcm_sym11__;
+      current_statement__ = 1;
+      validate_non_negative_index("a", "n_pair", n_pair);
+      Eigen::Matrix<double, -1, 1> a;
+      a = Eigen::Matrix<double, -1, 1>(n_pair);
+      stan::math::fill(a, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 1;
+      a = in__.vector(n_pair);
+      current_statement__ = 2;
+      validate_non_negative_index("beta", "2", 2);
+      Eigen::Matrix<double, -1, 1> beta;
+      beta = Eigen::Matrix<double, -1, 1>(2);
+      stan::math::fill(beta, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 2;
+      beta = in__.vector(2);
+      double mu_a;
+      mu_a = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      mu_a = in__.scalar();
+      double sigma_a;
+      sigma_a = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      sigma_a = in__.scalar();
+      current_statement__ = 4;
+      sigma_a = stan::math::lub_constrain(sigma_a, 0, 100);
+      double sigma_y;
+      sigma_y = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 5;
+      sigma_y = in__.scalar();
+      current_statement__ = 5;
+      sigma_y = stan::math::lub_constrain(sigma_y, 0, 100);
+      current_statement__ = 6;
+      validate_non_negative_index("y_hat", "N", N);
+      Eigen::Matrix<local_scalar_t__, -1, 1> y_hat;
+      y_hat = Eigen::Matrix<local_scalar_t__, -1, 1>(N);
+      stan::math::fill(y_hat, DUMMY_VAR__);
+      
+      if (logical_gte(n_pair, 1)) {
+        vars__.push_back(
+          rvalue(a, cons_list(index_uni(1), nil_index_list()), "a"));
+        for (int sym1__ = 2; sym1__ <= n_pair; ++sym1__) {
+          vars__.push_back(a[(sym1__ - 1)]);}
+      } 
+      {
+        vars__.push_back(
+          rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"));
+        {
+          vars__.push_back(
+            rvalue(beta, cons_list(index_uni(2), nil_index_list()), "beta"));
+        }
+      }
+      vars__.push_back(mu_a);
+      vars__.push_back(sigma_a);
+      vars__.push_back(sigma_y);
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      lcm_sym11__ = logical_gte(N, 1);
+      if (lcm_sym11__) {
+        current_statement__ = 7;
+        assign(y_hat, cons_list(index_uni(1), nil_index_list()),
+          stan::math::fma(
+            rvalue(beta, cons_list(index_uni(2), nil_index_list()), "beta"),
+            rvalue(pre_test, cons_list(index_uni(1), nil_index_list()),
+              "pre_test"),
+            stan::math::fma(
+              rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"),
+              rvalue(treatment, cons_list(index_uni(1), nil_index_list()),
+                "treatment"),
+              rvalue(a,
+                cons_list(
+                  index_uni(rvalue(pair,
+                              cons_list(index_uni(1), nil_index_list()),
+                              "pair")), nil_index_list()), "a"))),
+          "assigning variable y_hat");
+        for (int i = 2; i <= N; ++i) {
+          current_statement__ = 7;
+          assign(y_hat, cons_list(index_uni(i), nil_index_list()),
+            stan::math::fma(
+              rvalue(beta, cons_list(index_uni(2), nil_index_list()), "beta"),
+              rvalue(pre_test, cons_list(index_uni(i), nil_index_list()),
+                "pre_test"),
+              stan::math::fma(
+                rvalue(beta, cons_list(index_uni(1), nil_index_list()),
+                  "beta"),
+                rvalue(treatment, cons_list(index_uni(i), nil_index_list()),
+                  "treatment"),
+                rvalue(a,
+                  cons_list(
+                    index_uni(rvalue(pair,
+                                cons_list(index_uni(i), nil_index_list()),
+                                "pair")), nil_index_list()), "a"))),
+            "assigning variable y_hat");}
+      } 
+      if (lcm_sym11__) {
+        vars__.push_back(
+          rvalue(y_hat, cons_list(index_uni(1), nil_index_list()), "y_hat"));
+        for (int sym1__ = 2; sym1__ <= N; ++sym1__) {
+          vars__.push_back(y_hat[(sym1__ - 1)]);}
+      } 
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // write_array() 
+    
+  inline void transform_inits(const stan::io::var_context& context__,
+                              std::vector<int>& params_i__,
+                              std::vector<double>& vars__,
+                              std::ostream* pstream__) const {
+    typedef double local_scalar_t__;
+    vars__.resize(0);
+    vars__.reserve(num_params_r__);
+    
+    try {
+      double lcm_sym10__;
+      double lcm_sym9__;
+      double lcm_sym8__;
+      double lcm_sym7__;
+      double lcm_sym6__;
+      double lcm_sym5__;
+      double lcm_sym4__;
+      double lcm_sym3__;
+      int lcm_sym2__;
+      int lcm_sym1__;
+      int pos__;
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      current_statement__ = 1;
+      validate_non_negative_index("a", "n_pair", n_pair);
+      Eigen::Matrix<double, -1, 1> a;
+      a = Eigen::Matrix<double, -1, 1>(n_pair);
+      stan::math::fill(a, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> a_flat__;
+        current_statement__ = 1;
+        assign(a_flat__, nil_index_list(), context__.vals_r("a"),
+          "assigning variable a_flat__");
+        current_statement__ = 1;
+        pos__ = 1;
+        lcm_sym1__ = logical_gte(n_pair, 1);
+        if (lcm_sym1__) {
+          current_statement__ = 1;
+          assign(a, cons_list(index_uni(1), nil_index_list()),
+            rvalue(a_flat__, cons_list(index_uni(1), nil_index_list()),
+              "a_flat__"), "assigning variable a");
+          current_statement__ = 1;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= n_pair; ++sym1__) {
+            current_statement__ = 1;
+            assign(a, cons_list(index_uni(sym1__), nil_index_list()),
+              a_flat__[(pos__ - 1)], "assigning variable a");
+            current_statement__ = 1;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 2;
+      validate_non_negative_index("beta", "2", 2);
+      Eigen::Matrix<double, -1, 1> beta;
+      beta = Eigen::Matrix<double, -1, 1>(2);
+      stan::math::fill(beta, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> beta_flat__;
+        current_statement__ = 2;
+        assign(beta_flat__, nil_index_list(), context__.vals_r("beta"),
+          "assigning variable beta_flat__");
+        current_statement__ = 2;
+        pos__ = 1;
+        {
+          current_statement__ = 2;
+          assign(beta, cons_list(index_uni(1), nil_index_list()),
+            rvalue(beta_flat__, cons_list(index_uni(1), nil_index_list()),
+              "beta_flat__"), "assigning variable beta");
+          current_statement__ = 2;
+          pos__ = 2;
+          {
+            current_statement__ = 2;
+            assign(beta, cons_list(index_uni(2), nil_index_list()),
+              beta_flat__[(pos__ - 1)], "assigning variable beta");
+            current_statement__ = 2;
+            pos__ = (pos__ + 1);
+          }
+        }
+      }
+      double mu_a;
+      mu_a = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      mu_a = context__.vals_r("mu_a")[(1 - 1)];
+      double sigma_a;
+      sigma_a = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      sigma_a = context__.vals_r("sigma_a")[(1 - 1)];
+      current_statement__ = 4;
+      sigma_a = stan::math::lub_free(sigma_a, 0, 100);
+      double sigma_y;
+      sigma_y = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 5;
+      sigma_y = context__.vals_r("sigma_y")[(1 - 1)];
+      current_statement__ = 5;
+      sigma_y = stan::math::lub_free(sigma_y, 0, 100);
+      if (lcm_sym1__) {
+        vars__.push_back(
+          rvalue(a, cons_list(index_uni(1), nil_index_list()), "a"));
+        for (int sym1__ = 2; sym1__ <= n_pair; ++sym1__) {
+          vars__.push_back(a[(sym1__ - 1)]);}
+      } 
+      {
+        vars__.push_back(
+          rvalue(beta, cons_list(index_uni(1), nil_index_list()), "beta"));
+        {
+          vars__.push_back(
+            rvalue(beta, cons_list(index_uni(2), nil_index_list()), "beta"));
+        }
+      }
+      vars__.push_back(mu_a);
+      vars__.push_back(sigma_a);
+      vars__.push_back(sigma_y);
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    } // transform_inits() 
+    
+  inline void get_param_names(std::vector<std::string>& names__) const {
+    
+    names__.resize(0);
+    names__.push_back("a");
+    names__.push_back("beta");
+    names__.push_back("mu_a");
+    names__.push_back("sigma_a");
+    names__.push_back("sigma_y");
+    names__.push_back("y_hat");
+    } // get_param_names() 
+    
+  inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
+    dimss__.resize(0);
+    std::vector<size_t> dims__;
+    dims__.push_back(n_pair);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(2);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(N);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    
+    } // get_dims() 
+    
+  inline void constrained_param_names(
+                                      std::vector<std::string>& param_names__,
+                                      bool emit_transformed_parameters__ = true,
+                                      bool emit_generated_quantities__ = true) const {
+    
+    for (int sym40__ = 1; sym40__ <= n_pair; ++sym40__) {
+      {
+        param_names__.push_back(std::string() + "a" + '.' + std::to_string(sym40__));
+      }}
+    for (int sym40__ = 1; sym40__ <= 2; ++sym40__) {
+      {
+        param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym40__));
+      }}
+    param_names__.push_back(std::string() + "mu_a");
+    param_names__.push_back(std::string() + "sigma_a");
+    param_names__.push_back(std::string() + "sigma_y");
+    if (emit_transformed_parameters__) {
+      for (int sym40__ = 1; sym40__ <= N; ++sym40__) {
+        {
+          param_names__.push_back(std::string() + "y_hat" + '.' + std::to_string(sym40__));
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // constrained_param_names() 
+    
+  inline void unconstrained_param_names(
+                                        std::vector<std::string>& param_names__,
+                                        bool emit_transformed_parameters__ = true,
+                                        bool emit_generated_quantities__ = true) const {
+    
+    for (int sym40__ = 1; sym40__ <= n_pair; ++sym40__) {
+      {
+        param_names__.push_back(std::string() + "a" + '.' + std::to_string(sym40__));
+      }}
+    for (int sym40__ = 1; sym40__ <= 2; ++sym40__) {
+      {
+        param_names__.push_back(std::string() + "beta" + '.' + std::to_string(sym40__));
+      }}
+    param_names__.push_back(std::string() + "mu_a");
+    param_names__.push_back(std::string() + "sigma_a");
+    param_names__.push_back(std::string() + "sigma_y");
+    if (emit_transformed_parameters__) {
+      for (int sym40__ = 1; sym40__ <= N; ++sym40__) {
+        {
+          param_names__.push_back(std::string() + "y_hat" + '.' + std::to_string(sym40__));
+        }}
+    }
+    
+    if (emit_generated_quantities__) {
+      
+    }
+    
+    } // unconstrained_param_names() 
+    
+  inline std::string get_constrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"a\",\"type\":{\"name\":\"vector\",\"length\":" << n_pair << "},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"mu_a\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_a\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_y\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_constrained_sizedtypes() 
+    
+  inline std::string get_unconstrained_sizedtypes() const {
+    stringstream s__;
+    s__ << "[{\"name\":\"a\",\"type\":{\"name\":\"vector\",\"length\":" << n_pair << "},\"block\":\"parameters\"},{\"name\":\"beta\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"mu_a\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_a\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"sigma_y\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"y_hat\",\"type\":{\"name\":\"vector\",\"length\":" << N << "},\"block\":\"transformed_parameters\"}]";
+    return s__.str();
+    } // get_unconstrained_sizedtypes() 
+    
+  
+    // Begin method overload boilerplate
+    template <typename RNG>
+    void write_array(RNG& base_rng__,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& params_r,
+                     Eigen::Matrix<double,Eigen::Dynamic,1>& vars,
+                     bool emit_transformed_parameters__ = true,
+                     bool emit_generated_quantities__ = true,
+                     std::ostream* pstream = 0) const {
+      std::vector<double> params_r_vec(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r_vec[i] = params_r(i);
+      std::vector<double> vars_vec;
+      std::vector<int> params_i_vec;
+      write_array(base_rng__, params_r_vec, params_i_vec, vars_vec,
+          emit_transformed_parameters__, emit_generated_quantities__, pstream);
+      vars.resize(vars_vec.size());
+      for (int i = 0; i < vars.size(); ++i)
+        vars(i) = vars_vec[i];
+    }
+
+    template <bool propto__, bool jacobian__, typename T_>
+    T_ log_prob(Eigen::Matrix<T_,Eigen::Dynamic,1>& params_r,
+               std::ostream* pstream = 0) const {
+      std::vector<T_> vec_params_r;
+      vec_params_r.reserve(params_r.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        vec_params_r.push_back(params_r(i));
+      std::vector<int> vec_params_i;
+      return log_prob<propto__,jacobian__,T_>(vec_params_r, vec_params_i, pstream);
+    }
+
+    void transform_inits(const stan::io::var_context& context,
+                         Eigen::Matrix<double, Eigen::Dynamic, 1>& params_r,
+                         std::ostream* pstream__) const {
+      std::vector<double> params_r_vec;
+      std::vector<int> params_i_vec;
+      transform_inits(context, params_i_vec, params_r_vec, pstream__);
+      params_r.resize(params_r_vec.size());
+      for (int i = 0; i < params_r.size(); ++i)
+        params_r(i) = params_r_vec[i];
+    }
+
+};
+}
+typedef partial_eval_model_namespace::partial_eval_model stan_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;
+}
+
+#endif
+
+
+
+  $ ../../../../../install/default/bin/stanc --O --print-cpp stalled1-failure.stan
+
+// Code generated by %%NAME%% %%VERSION%%
+#include <stan/model/model_header.hpp>
+namespace stalled1_failure_model_namespace {
+
+template <typename T, typename S>
+std::vector<T> resize_to_match__(std::vector<T>& dst, const std::vector<S>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, -1>
+resize_to_match__(Eigen::Matrix<T, -1, -1>& dst, const Eigen::Matrix<T, -1, -1>& src) {
+  dst.resize(src.rows(), src.cols());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, 1, -1>
+resize_to_match__(Eigen::Matrix<T, 1, -1>& dst, const Eigen::Matrix<T, 1, -1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+
+template <typename T>
+Eigen::Matrix<T, -1, 1>
+resize_to_match__(Eigen::Matrix<T, -1, 1>& dst, const Eigen::Matrix<T, -1, 1>& src) {
+  dst.resize(src.size());
+  return dst;
+}
+std::vector<double> to_doubles__(std::initializer_list<double> x) {
+  return x;
+}
+
+std::vector<stan::math::var> to_vars__(std::initializer_list<stan::math::var> x) {
+  return x;
+}
+
+inline void validate_positive_index(const char* var_name, const char* expr,
+                                    int val) {
+  if (val < 1) {
+    std::stringstream msg;
+    msg << "Found dimension size less than one in simplex declaration"
+        << "; variable=" << var_name << "; dimension size expression=" << expr
+        << "; expression value=" << val;
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+inline void validate_unit_vector_index(const char* var_name, const char* expr,
+                                       int val) {
+  if (val <= 1) {
+    std::stringstream msg;
+    if (val == 1) {
+      msg << "Found dimension size one in unit vector declaration."
+          << " One-dimensional unit vector is discrete"
+          << " but the target distribution must be continuous."
+          << " variable=" << var_name << "; dimension size expression=" << expr;
+    } else {
+      msg << "Found dimension size less than one in unit vector declaration"
+          << "; variable=" << var_name << "; dimension size expression=" << expr
+          << "; expression value=" << val;
+    }
+    std::string msg_str(msg.str());
+    throw std::invalid_argument(msg_str.c_str());
+  }
+}
+
+
+using std::istream;
+using std::string;
+using std::stringstream;
+using std::vector;
+using std::pow;
+using stan::io::dump;
+using stan::math::lgamma;
+using stan::model::model_base_crtp;
+using stan::model::rvalue;
+using stan::model::cons_list;
+using stan::model::index_uni;
+using stan::model::index_max;
+using stan::model::index_min;
+using stan::model::index_min_max;
+using stan::model::index_multi;
+using stan::model::index_omni;
+using stan::model::nil_index_list;
+using namespace stan::math; 
+
+static int current_statement__ = 0;
+static const std::vector<string> locations_array__ = {" (found before start of program)",
+                                                      " (in 'stalled1-failure.stan', line 30, column 4 to column 16)",
+                                                      " (in 'stalled1-failure.stan', line 31, column 4 to column 16)",
+                                                      " (in 'stalled1-failure.stan', line 32, column 4 to column 16)",
+                                                      " (in 'stalled1-failure.stan', line 33, column 4 to column 17)",
+                                                      " (in 'stalled1-failure.stan', line 34, column 4 to column 22)",
+                                                      " (in 'stalled1-failure.stan', line 35, column 4 to column 19)",
+                                                      " (in 'stalled1-failure.stan', line 39, column 4 to column 15)",
+                                                      " (in 'stalled1-failure.stan', line 44, column 3 to column 31)",
+                                                      " (in 'stalled1-failure.stan', line 45, column 3 to column 31)",
+                                                      " (in 'stalled1-failure.stan', line 46, column 3 to column 31)",
+                                                      " (in 'stalled1-failure.stan', line 47, column 3 to column 32)",
+                                                      " (in 'stalled1-failure.stan', line 48, column 3 to column 31)",
+                                                      " (in 'stalled1-failure.stan', line 50, column 6 to column 32)",
+                                                      " (in 'stalled1-failure.stan', line 51, column 6 to column 103)",
+                                                      " (in 'stalled1-failure.stan', line 49, column 18 to line 52, column 4)",
+                                                      " (in 'stalled1-failure.stan', line 49, column 3 to line 52, column 4)",
+                                                      " (in 'stalled1-failure.stan', line 15, column 4 to column 19)",
+                                                      " (in 'stalled1-failure.stan', line 16, column 4 to column 22)",
+                                                      " (in 'stalled1-failure.stan', line 17, column 4 to column 22)",
+                                                      " (in 'stalled1-failure.stan', line 18, column 4 to column 17)",
+                                                      " (in 'stalled1-failure.stan', line 19, column 4 to column 17)",
+                                                      " (in 'stalled1-failure.stan', line 23, column 4 to column 10)",
+                                                      " (in 'stalled1-failure.stan', line 24, column 4 to column 19)",
+                                                      " (in 'stalled1-failure.stan', line 25, column 4 to column 11)",
+                                                      " (in 'stalled1-failure.stan', line 26, column 4 to column 21)"};
+
+
+
+class stalled1_failure_model : public model_base_crtp<stalled1_failure_model> {
+
+ private:
+  double lcm_sym38__;
+  double lcm_sym37__;
+  double lcm_sym36__;
+  double lcm_sym35__;
+  int lcm_sym34__;
+  int lcm_sym33__;
+  int lcm_sym32__;
+  int lcm_sym31__;
+  int lcm_sym30__;
+  int lcm_sym29__;
+  Eigen::Matrix<double, -1, 1> lcm_sym28__;
+  int pos__;
+  int I;
+  std::vector<int> n;
+  std::vector<int> N;
+  Eigen::Matrix<double, -1, 1> x1;
+  Eigen::Matrix<double, -1, 1> x2;
+  int K;
+  Eigen::Matrix<double, -1, 1> x1x2;
+ 
+ public:
+  ~stalled1_failure_model() { }
+  
+  std::string model_name() const { return "stalled1_failure_model"; }
+  
+  stalled1_failure_model(stan::io::var_context& context__,
+                         unsigned int random_seed__ = 0,
+                         std::ostream* pstream__ = nullptr) : model_base_crtp(0) {
+    typedef double local_scalar_t__;
+    boost::ecuyer1988 base_rng__ = 
+        stan::services::util::create_rng(random_seed__, 0);
+    (void) base_rng__;  // suppress unused var warning
+    static const char* function__ = "stalled1_failure_model_namespace::stalled1_failure_model";
+    (void) function__;  // suppress unused var warning
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+    
+    try {
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      pos__ = std::numeric_limits<int>::min();
+      
+      pos__ = 1;
+      context__.validate_dims("data initialization","I","int",
+          context__.to_vec());
+      I = std::numeric_limits<int>::min();
+      
+      current_statement__ = 17;
+      I = context__.vals_i("I")[(1 - 1)];
+      current_statement__ = 18;
+      validate_non_negative_index("n", "I", I);
+      context__.validate_dims("data initialization","n","int",
+          context__.to_vec(I));
+      n = std::vector<int>(I, std::numeric_limits<int>::min());
+      
+      current_statement__ = 18;
+      assign(n, nil_index_list(), context__.vals_i("n"),
+        "assigning variable n");
+      current_statement__ = 19;
+      validate_non_negative_index("N", "I", I);
+      context__.validate_dims("data initialization","N","int",
+          context__.to_vec(I));
+      N = std::vector<int>(I, std::numeric_limits<int>::min());
+      
+      current_statement__ = 19;
+      assign(N, nil_index_list(), context__.vals_i("N"),
+        "assigning variable N");
+      current_statement__ = 20;
+      validate_non_negative_index("x1", "I", I);
+      context__.validate_dims("data initialization","x1","double",
+          context__.to_vec(I));
+      x1 = Eigen::Matrix<double, -1, 1>(I);
+      stan::math::fill(x1, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> x1_flat__;
+        current_statement__ = 20;
+        assign(x1_flat__, nil_index_list(), context__.vals_r("x1"),
+          "assigning variable x1_flat__");
+        current_statement__ = 20;
+        pos__ = 1;
+        lcm_sym29__ = logical_gte(I, 1);
+        if (lcm_sym29__) {
+          current_statement__ = 20;
+          assign(x1, cons_list(index_uni(1), nil_index_list()),
+            rvalue(x1_flat__, cons_list(index_uni(1), nil_index_list()),
+              "x1_flat__"), "assigning variable x1");
+          current_statement__ = 20;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= I; ++sym1__) {
+            current_statement__ = 20;
+            assign(x1, cons_list(index_uni(sym1__), nil_index_list()),
+              x1_flat__[(pos__ - 1)], "assigning variable x1");
+            current_statement__ = 20;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      current_statement__ = 21;
+      validate_non_negative_index("x2", "I", I);
+      context__.validate_dims("data initialization","x2","double",
+          context__.to_vec(I));
+      x2 = Eigen::Matrix<double, -1, 1>(I);
+      stan::math::fill(x2, std::numeric_limits<double>::quiet_NaN());
+      
+      {
+        std::vector<double> x2_flat__;
+        current_statement__ = 21;
+        assign(x2_flat__, nil_index_list(), context__.vals_r("x2"),
+          "assigning variable x2_flat__");
+        current_statement__ = 21;
+        pos__ = 1;
+        current_statement__ = 21;
+        if (lcm_sym29__) {
+          current_statement__ = 21;
+          assign(x2, cons_list(index_uni(1), nil_index_list()),
+            rvalue(x2_flat__, cons_list(index_uni(1), nil_index_list()),
+              "x2_flat__"), "assigning variable x2");
+          current_statement__ = 21;
+          pos__ = 2;
+          for (int sym1__ = 2; sym1__ <= I; ++sym1__) {
+            current_statement__ = 21;
+            assign(x2, cons_list(index_uni(sym1__), nil_index_list()),
+              x2_flat__[(pos__ - 1)], "assigning variable x2");
+            current_statement__ = 21;
+            pos__ = (pos__ + 1);}
+        } 
+      }
+      K = std::numeric_limits<int>::min();
+      
+      current_statement__ = 23;
+      validate_non_negative_index("x1x2", "I", I);
+      x1x2 = Eigen::Matrix<double, -1, 1>(I);
+      stan::math::fill(x1x2, std::numeric_limits<double>::quiet_NaN());
+      
+      current_statement__ = 24;
+      K = 8;
+      current_statement__ = 25;
+      assign(x1x2, nil_index_list(), elt_multiply(x1, x2),
+        "assigning variable x1x2");
+      current_statement__ = 17;
+      current_statement__ = 17;
+      check_greater_or_equal(function__, "I", I, 0);
+      current_statement__ = 18;
+      if (lcm_sym29__) {
+        current_statement__ = 18;
+        current_statement__ = 18;
+        check_greater_or_equal(function__, "n[sym1__]",
+                               rvalue(n,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "n"), 0);
+        for (int sym1__ = 2; sym1__ <= I; ++sym1__) {
+          current_statement__ = 18;
+          current_statement__ = 18;
+          check_greater_or_equal(function__, "n[sym1__]", n[(sym1__ - 1)], 0);
+        }
+      } 
+      current_statement__ = 19;
+      if (lcm_sym29__) {
+        current_statement__ = 19;
+        current_statement__ = 19;
+        check_greater_or_equal(function__, "N[sym1__]",
+                               rvalue(N,
+                                 cons_list(index_uni(1), nil_index_list()),
+                                 "N"), 0);
+        for (int sym1__ = 2; sym1__ <= I; ++sym1__) {
+          current_statement__ = 19;
+          current_statement__ = 19;
+          check_greater_or_equal(function__, "N[sym1__]", N[(sym1__ - 1)], 0);
+        }
+      } 
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    num_params_r__ = 0U;
+    
+    try {
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      num_params_r__ += 1;
+      current_statement__ = 6;
+      validate_non_negative_index("b", "I", I);
+      current_statement__ = 6;
+      validate_non_negative_index("b", "K", K);
+      num_params_r__ += I * K;
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+  }
+  template <bool propto__, bool jacobian__, typename T__>
+  inline T__ log_prob(std::vector<T__>& params_r__,
+                      std::vector<int>& params_i__,
+                      std::ostream* pstream__ = 0) const {
+    typedef T__ local_scalar_t__;
+    T__ lp__(0.0);
+    stan::math::accumulator<T__> lp_accum__;
+    static const char* function__ = "stalled1_failure_model_namespace::log_prob";
+(void) function__;  // suppress unused var warning
+
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym27__;
+      double lcm_sym26__;
+      double lcm_sym25__;
+      double lcm_sym24__;
+      double lcm_sym23__;
+      double lcm_sym22__;
+      double lcm_sym21__;
+      double lcm_sym20__;
+      double lcm_sym19__;
+      int lcm_sym18__;
+      local_scalar_t__ lcm_sym17__;
+      local_scalar_t__ alpha0;
+      alpha0 = DUMMY_VAR__;
+      
+      current_statement__ = 1;
+      alpha0 = in__.scalar();
+      local_scalar_t__ alpha1;
+      alpha1 = DUMMY_VAR__;
+      
+      current_statement__ = 2;
+      alpha1 = in__.scalar();
+      local_scalar_t__ alpha2;
+      alpha2 = DUMMY_VAR__;
+      
+      current_statement__ = 3;
+      alpha2 = in__.scalar();
+      local_scalar_t__ alpha12;
+      alpha12 = DUMMY_VAR__;
+      
+      current_statement__ = 4;
+      alpha12 = in__.scalar();
+      local_scalar_t__ tau;
+      tau = DUMMY_VAR__;
+      
+      current_statement__ = 5;
+      tau = in__.scalar();
+      current_statement__ = 5;
+      if (jacobian__) {
+        current_statement__ = 5;
+        tau = stan::math::lb_constrain(tau, 0, lp__);
+      } else {
+        current_statement__ = 5;
+        tau = stan::math::lb_constrain(tau, 0);
+      }
+      current_statement__ = 6;
+      validate_non_negative_index("b", "I", I);
+      current_statement__ = 6;
+      validate_non_negative_index("b", "K", 8);
+      std::vector<Eigen::Matrix<local_scalar_t__, -1, 1>> b;
+      b = std::vector<Eigen::Matrix<local_scalar_t__, -1, 1>>(I, Eigen::Matrix<local_scalar_t__, -1, 1>(8));
+      stan::math::fill(b, DUMMY_VAR__);
+      
+      lcm_sym18__ = logical_gte(I, 1);
+      if (lcm_sym18__) {
+        current_statement__ = 6;
+        assign(b, cons_list(index_uni(1), nil_index_list()), in__.vector(8),
+          "assigning variable b");
+        for (int sym1__ = 2; sym1__ <= I; ++sym1__) {
+          current_statement__ = 6;
+          assign(b, cons_list(index_uni(sym1__), nil_index_list()),
+            in__.vector(8), "assigning variable b");}
+      } 
+      local_scalar_t__ sigma;
+      sigma = DUMMY_VAR__;
+      
+      lcm_sym17__ = (1 / stan::math::sqrt(tau));
+      sigma = lcm_sym17__;
+      {
+        current_statement__ = 8;
+        lp_accum__.add(normal_log<propto__>(alpha0, 0.0, 1.0E3));
+        current_statement__ = 9;
+        lp_accum__.add(normal_log<propto__>(alpha1, 0.0, 1.0E3));
+        current_statement__ = 10;
+        lp_accum__.add(normal_log<propto__>(alpha2, 0.0, 1.0E3));
+        current_statement__ = 11;
+        lp_accum__.add(normal_log<propto__>(alpha12, 0.0, 1.0E3));
+        current_statement__ = 12;
+        lp_accum__.add(gamma_log<propto__>(tau, 1.0E-3, 1.0E-3));
+        current_statement__ = 16;
+        if (lcm_sym18__) {
+          current_statement__ = 13;
+          lp_accum__.add(
+            normal_log<propto__>(
+              rvalue(b, cons_list(index_uni(1), nil_index_list()), "b"), 0.0,
+              lcm_sym17__));
+          current_statement__ = 14;
+          lp_accum__.add(
+            binomial_logit_log<propto__>(
+              rvalue(n, cons_list(index_uni(1), nil_index_list()), "n"),
+              rvalue(N, cons_list(index_uni(1), nil_index_list()), "N"),
+              add(
+                stan::math::fma(alpha12,
+                  rvalue(elt_multiply(x1, x2),
+                    cons_list(index_uni(1), nil_index_list()), "(x1 .* x2)"),
+                  stan::math::fma(alpha2,
+                    rvalue(x2, cons_list(index_uni(1), nil_index_list()),
+                      "x2"),
+                    stan::math::fma(alpha1,
+                      rvalue(x1, cons_list(index_uni(1), nil_index_list()),
+                        "x1"), alpha0))),
+                rvalue(b, cons_list(index_uni(1), nil_index_list()), "b"))));
+          for (int i = 2; i <= I; ++i) {
+            current_statement__ = 13;
+            lp_accum__.add(
+              normal_log<propto__>(
+                rvalue(b, cons_list(index_uni(i), nil_index_list()), "b"),
+                0.0, lcm_sym17__));
+            current_statement__ = 14;
+            lp_accum__.add(
+              binomial_logit_log<propto__>(
+                rvalue(n, cons_list(index_uni(i), nil_index_list()), "n"),
+                rvalue(N, cons_list(index_uni(i), nil_index_list()), "N"),
+                add(
+                  stan::math::fma(alpha12,
+                    rvalue(elt_multiply(x1, x2),
+                      cons_list(index_uni(i), nil_index_list()),
+                      "(x1 .* x2)"),
+                    stan::math::fma(alpha2,
+                      rvalue(x2, cons_list(index_uni(i), nil_index_list()),
+                        "x2"),
+                      stan::math::fma(alpha1,
+                        rvalue(x1, cons_list(index_uni(i), nil_index_list()),
+                          "x1"), alpha0))),
+                  rvalue(b, cons_list(index_uni(i), nil_index_list()), "b"))));
+          }
+        } 
+      }
+    } catch (const std::exception& e) {
+      stan::lang::rethrow_located(e, locations_array__[current_statement__]);
+      // Next line prevents compiler griping about no return
+      throw std::runtime_error("*** IF YOU SEE THIS, PLEASE REPORT A BUG ***"); 
+    }
+    lp_accum__.add(lp__);
+    return lp_accum__.sum();
+    } // log_prob() 
+    
+  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__ = 0) const {
+    using local_scalar_t__ = double;
+    vars__.resize(0);
+    stan::io::reader<local_scalar_t__> in__(params_r__, params_i__);
+    static const char* function__ = "stalled1_failure_model_namespace::write_array";
+(void) function__;  // suppress unused var warning
+
+    (void) function__;  // suppress unused var warning
+
+    double lp__ = 0.0;
+    (void) lp__;  // dummy to suppress unused var warning
+    stan::math::accumulator<double> lp_accum__;
+    local_scalar_t__ DUMMY_VAR__(std::numeric_limits<double>::quiet_NaN());
+    (void) DUMMY_VAR__;  // suppress unused var warning
+
+    
+    try {
+      double lcm_sym16__;
+      double lcm_sym15__;
+      double lcm_sym14__;
+      double lcm_sym13__;
+      int lcm_sym12__;
+      int lcm_sym11__;
+      int lcm_sym10__;
+      double lcm_sym9__;
+      double alpha0;
+      alpha0 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 1;
+      alpha0 = in__.scalar();
+      double alpha1;
+      alpha1 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      alpha1 = in__.scalar();
+      double alpha2;
+      alpha2 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 3;
+      alpha2 = in__.scalar();
+      double alpha12;
+      alpha12 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 4;
+      alpha12 = in__.scalar();
+      double tau;
+      tau = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 5;
+      tau = in__.scalar();
+      current_statement__ = 5;
+      tau = stan::math::lb_constrain(tau, 0);
+      current_statement__ = 6;
+      validate_non_negative_index("b", "I", I);
+      current_statement__ = 6;
+      validate_non_negative_index("b", "K", 8);
+      std::vector<Eigen::Matrix<double, -1, 1>> b;
+      b = std::vector<Eigen::Matrix<double, -1, 1>>(I, Eigen::Matrix<double, -1, 1>(8));
+      stan::math::fill(b, std::numeric_limits<double>::quiet_NaN());
+      
+      lcm_sym10__ = logical_gte(I, 1);
+      if (lcm_sym10__) {
+        current_statement__ = 6;
+        assign(b, cons_list(index_uni(1), nil_index_list()), in__.vector(8),
+          "assigning variable b");
+        for (int sym1__ = 2; sym1__ <= I; ++sym1__) {
+          current_statement__ = 6;
+          assign(b, cons_list(index_uni(sym1__), nil_index_list()),
+            in__.vector(8), "assigning variable b");}
+      } 
+      double sigma;
+      sigma = std::numeric_limits<double>::quiet_NaN();
+      
+      vars__.push_back(alpha0);
+      vars__.push_back(alpha1);
+      vars__.push_back(alpha2);
+      vars__.push_back(alpha12);
+      vars__.push_back(tau);
+      {
+        if (lcm_sym10__) {
+          vars__.push_back(
+            rvalue(b,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "b"));
+          for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "b"));}
+        } 
+        {
+          if (lcm_sym10__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(2), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              vars__.push_back(
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(2), nil_index_list())), "b"));}
+          } 
+        }
+        {
+          if (lcm_sym10__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(3), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              vars__.push_back(
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(3), nil_index_list())), "b"));}
+          } 
+        }
+        {
+          if (lcm_sym10__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(4), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              vars__.push_back(
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(4), nil_index_list())), "b"));}
+          } 
+        }
+        {
+          if (lcm_sym10__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(5), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              vars__.push_back(
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(5), nil_index_list())), "b"));}
+          } 
         }
-      }
-      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
-            primitive_value(emit_generated_quantities__)))) {
         {
-          return ;
+          if (lcm_sym10__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(6), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              vars__.push_back(
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(6), nil_index_list())), "b"));}
+          } 
+        }
+        {
+          if (lcm_sym10__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(7), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              vars__.push_back(
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(7), nil_index_list())), "b"));}
+          } 
         }
-      } else ;
-      if (logical_negation(emit_generated_quantities__)) {
         {
-          return ;
+          if (lcm_sym10__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(8), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              vars__.push_back(
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(8), nil_index_list())), "b"));}
+          } 
         }
-      } else ;
+      }
+      if (logical_negation((primitive_value(emit_transformed_parameters__) ||
+            primitive_value(emit_generated_quantities__)))) {
+        return ;
+      } 
+      lcm_sym9__ = (1 / stan::math::sqrt(tau));
+      sigma = lcm_sym9__;
+      vars__.push_back(lcm_sym9__);
+      if (logical_negation(emit_generated_quantities__)) {
+        return ;
+      } 
     } catch (const std::exception& e) {
       stan::lang::rethrow_located(e, locations_array__[current_statement__]);
       // Next line prevents compiler griping about no return
@@ -1335,348 +33156,330 @@ class optimizations_model : public model_base_crtp<optimizations_model> {
     vars__.reserve(num_params_r__);
     
     try {
-      double sym59__;
-      double sym58__;
-      double sym57__;
-      double sym56__;
-      double sym55__;
-      double sym54__;
-      double sym53__;
-      double sym52__;
-      double sym51__;
-      double sym50__;
-      double sym49__;
-      double sym48__;
-      double sym47__;
-      double sym46__;
-      double sym45__;
-      double sym44__;
-      std::vector<double> sym43__;
-      std::vector<double> sym42__;
-      std::vector<double> sym41__;
-      int sym40__;
-      int sym39__;
-      int sym38__;
+      double lcm_sym8__;
+      double lcm_sym7__;
+      double lcm_sym6__;
+      double lcm_sym5__;
+      double lcm_sym4__;
+      double lcm_sym3__;
+      int lcm_sym2__;
+      int lcm_sym1__;
       int pos__;
       pos__ = std::numeric_limits<int>::min();
       
-      double theta;
-      theta = std::numeric_limits<double>::quiet_NaN();
+      pos__ = 1;
+      double alpha0;
+      alpha0 = std::numeric_limits<double>::quiet_NaN();
       
-      sym53__ = context__.vals_r("theta")[(1 - 1)];
-      double phi;
-      phi = std::numeric_limits<double>::quiet_NaN();
+      current_statement__ = 1;
+      alpha0 = context__.vals_r("alpha0")[(1 - 1)];
+      double alpha1;
+      alpha1 = std::numeric_limits<double>::quiet_NaN();
+      
+      current_statement__ = 2;
+      alpha1 = context__.vals_r("alpha1")[(1 - 1)];
+      double alpha2;
+      alpha2 = std::numeric_limits<double>::quiet_NaN();
       
-      sym52__ = context__.vals_r("phi")[(1 - 1)];
-      current_statement__ = 3;
-      validate_non_negative_index("x_matrix", "3", 3);
       current_statement__ = 3;
-      validate_non_negative_index("x_matrix", "2", 2);
-      Eigen::Matrix<double, -1, -1> x_matrix;
-      x_matrix = Eigen::Matrix<double, -1, -1>(3, 2);
-      stan::math::fill(x_matrix, std::numeric_limits<double>::quiet_NaN());
+      alpha2 = context__.vals_r("alpha2")[(1 - 1)];
+      double alpha12;
+      alpha12 = std::numeric_limits<double>::quiet_NaN();
       
-      {
-        std::vector<double> x_matrix_flat__;
-        assign(sym42__, nil_index_list(), context__.vals_r("x_matrix"),
-          "assigning variable sym42__");
-        {
-          {
-            {
-              {
-                {
-                  {
-                    current_statement__ = 3;
-                    assign(x_matrix,
-                      cons_list(index_uni(1),
-                        cons_list(index_uni(1), nil_index_list())),
-                      rvalue(sym42__,
-                        cons_list(index_uni(1), nil_index_list()), "sym42__"),
-                      "assigning variable x_matrix");
-                    current_statement__ = 3;
-                    pos__ = 2;
-                  }
-                  {
-                    {
-                      current_statement__ = 3;
-                      assign(x_matrix,
-                        cons_list(index_uni(2),
-                          cons_list(index_uni(1), nil_index_list())),
-                        sym42__[(pos__ - 1)], "assigning variable x_matrix");
-                      current_statement__ = 3;
-                      pos__ = (pos__ + 1);
-                    }
-                  }
-                  {
-                    {
-                      current_statement__ = 3;
-                      assign(x_matrix,
-                        cons_list(index_uni(3),
-                          cons_list(index_uni(1), nil_index_list())),
-                        sym42__[(pos__ - 1)], "assigning variable x_matrix");
-                      current_statement__ = 3;
-                      pos__ = (pos__ + 1);
-                    }
-                  }
-                }
-              }
-            }
-            {
-              {
-                {
-                  {
-                    {
-                      assign(x_matrix,
-                        cons_list(index_uni(1),
-                          cons_list(index_uni(2), nil_index_list())),
-                        sym42__[(pos__ - 1)], "assigning variable x_matrix");
-                      current_statement__ = 3;
-                      pos__ = (pos__ + 1);
-                    }
-                    {
-                      {
-                        current_statement__ = 3;
-                        assign(x_matrix,
-                          cons_list(index_uni(2),
-                            cons_list(index_uni(2), nil_index_list())),
-                          sym42__[(pos__ - 1)], "assigning variable x_matrix");
-                        current_statement__ = 3;
-                        pos__ = (pos__ + 1);
-                      }
-                    }
-                    {
-                      {
-                        current_statement__ = 3;
-                        assign(x_matrix,
-                          cons_list(index_uni(3),
-                            cons_list(index_uni(2), nil_index_list())),
-                          sym42__[(pos__ - 1)], "assigning variable x_matrix");
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
       current_statement__ = 4;
-      validate_non_negative_index("x_vector", "2", 2);
-      Eigen::Matrix<double, -1, 1> x_vector;
-      x_vector = Eigen::Matrix<double, -1, 1>(2);
-      stan::math::fill(x_vector, std::numeric_limits<double>::quiet_NaN());
+      alpha12 = context__.vals_r("alpha12")[(1 - 1)];
+      double tau;
+      tau = std::numeric_limits<double>::quiet_NaN();
       
-      {
-        std::vector<double> x_vector_flat__;
-        assign(sym43__, nil_index_list(), context__.vals_r("x_vector"),
-          "assigning variable sym43__");
-        {
-          {
-            {
-              current_statement__ = 4;
-              assign(x_vector, cons_list(index_uni(1), nil_index_list()),
-                rvalue(sym43__, cons_list(index_uni(1), nil_index_list()),
-                  "sym43__"), "assigning variable x_vector");
-              current_statement__ = 4;
-              pos__ = 2;
-            }
-            {
-              {
-                current_statement__ = 4;
-                assign(x_vector, cons_list(index_uni(2), nil_index_list()),
-                  sym43__[(pos__ - 1)], "assigning variable x_vector");
-              }
-            }
-          }
-        }
-      }
       current_statement__ = 5;
-      validate_non_negative_index("x_cov", "2", 2);
+      tau = context__.vals_r("tau")[(1 - 1)];
       current_statement__ = 5;
-      validate_non_negative_index("x_cov", "2", 2);
-      Eigen::Matrix<double, -1, -1> x_cov;
-      x_cov = Eigen::Matrix<double, -1, -1>(2, 2);
-      stan::math::fill(x_cov, std::numeric_limits<double>::quiet_NaN());
+      tau = stan::math::lb_free(tau, 0);
+      current_statement__ = 6;
+      validate_non_negative_index("b", "I", I);
+      current_statement__ = 6;
+      validate_non_negative_index("b", "K", 8);
+      std::vector<Eigen::Matrix<double, -1, 1>> b;
+      b = std::vector<Eigen::Matrix<double, -1, 1>>(I, Eigen::Matrix<double, -1, 1>(8));
+      stan::math::fill(b, std::numeric_limits<double>::quiet_NaN());
       
       {
-        std::vector<double> x_cov_flat__;
-        assign(sym41__, nil_index_list(), context__.vals_r("x_cov"),
-          "assigning variable sym41__");
+        std::vector<double> b_flat__;
+        current_statement__ = 6;
+        assign(b_flat__, nil_index_list(), context__.vals_r("b"),
+          "assigning variable b_flat__");
+        current_statement__ = 6;
+        pos__ = 1;
         {
+          lcm_sym1__ = logical_gte(I, 1);
+          if (lcm_sym1__) {
+            current_statement__ = 6;
+            assign(b,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())),
+              rvalue(b_flat__, cons_list(index_uni(1), nil_index_list()),
+                "b_flat__"), "assigning variable b");
+            current_statement__ = 6;
+            pos__ = 2;
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              current_statement__ = 6;
+              assign(b,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())),
+                b_flat__[(pos__ - 1)], "assigning variable b");
+              current_statement__ = 6;
+              pos__ = (pos__ + 1);}
+          } 
           {
-            {
-              {
-                {
-                  {
-                    current_statement__ = 5;
-                    assign(x_cov,
-                      cons_list(index_uni(1),
-                        cons_list(index_uni(1), nil_index_list())),
-                      rvalue(sym41__,
-                        cons_list(index_uni(1), nil_index_list()), "sym41__"),
-                      "assigning variable x_cov");
-                    current_statement__ = 5;
-                    pos__ = 2;
-                  }
-                  {
-                    {
-                      current_statement__ = 5;
-                      assign(x_cov,
-                        cons_list(index_uni(2),
-                          cons_list(index_uni(1), nil_index_list())),
-                        sym41__[(pos__ - 1)], "assigning variable x_cov");
-                      current_statement__ = 5;
-                      pos__ = (pos__ + 1);
-                    }
-                  }
-                }
-              }
-            }
-            {
-              {
-                {
-                  {
-                    {
-                      assign(x_cov,
-                        cons_list(index_uni(1),
-                          cons_list(index_uni(2), nil_index_list())),
-                        sym41__[(pos__ - 1)], "assigning variable x_cov");
-                      current_statement__ = 5;
-                      pos__ = (pos__ + 1);
-                    }
-                    {
-                      {
-                        current_statement__ = 5;
-                        assign(x_cov,
-                          cons_list(index_uni(2),
-                            cons_list(index_uni(2), nil_index_list())),
-                          sym41__[(pos__ - 1)], "assigning variable x_cov");
-                      }
-                    }
-                  }
-                }
-              }
-            }
+            current_statement__ = 6;
+            if (lcm_sym1__) {
+              current_statement__ = 6;
+              assign(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(2), nil_index_list())),
+                b_flat__[(pos__ - 1)], "assigning variable b");
+              current_statement__ = 6;
+              pos__ = (pos__ + 1);
+              for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+                current_statement__ = 6;
+                assign(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(2), nil_index_list())),
+                  b_flat__[(pos__ - 1)], "assigning variable b");
+                current_statement__ = 6;
+                pos__ = (pos__ + 1);}
+            } 
           }
-        }
-      }
-      current_statement__ = 5;
-      validate_non_negative_index("x_cov_free__",
-                                  "(2 + ((2 * (2 - 1)) / 2))", 3);
-      Eigen::Matrix<double, -1, 1> x_cov_free__;
-      x_cov_free__ = Eigen::Matrix<double, -1, 1>(3);
-      stan::math::fill(x_cov_free__, std::numeric_limits<double>::quiet_NaN());
-      
-      current_statement__ = 5;
-      assign(x_cov_free__, nil_index_list(),
-        stan::math::cov_matrix_free(x_cov), "assigning variable x_cov_free__");
-      vars__.push_back(sym53__);
-      vars__.push_back(sym52__);
-      {
-        {
           {
-            {
-              {
-                {
-                  vars__.push_back(
-                    rvalue(x_matrix,
-                      cons_list(index_uni(1),
-                        cons_list(index_uni(1), nil_index_list())),
-                      "x_matrix"));
-                }
-                {
-                  {
-                    vars__.push_back(
-                      rvalue(x_matrix,
-                        cons_list(index_uni(2),
-                          cons_list(index_uni(1), nil_index_list())),
-                        "x_matrix"));
-                  }
-                }
-                {
-                  {
-                    vars__.push_back(
-                      rvalue(x_matrix,
-                        cons_list(index_uni(3),
-                          cons_list(index_uni(1), nil_index_list())),
-                        "x_matrix"));
-                  }
-                }
-              }
-            }
+            current_statement__ = 6;
+            if (lcm_sym1__) {
+              current_statement__ = 6;
+              assign(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(3), nil_index_list())),
+                b_flat__[(pos__ - 1)], "assigning variable b");
+              current_statement__ = 6;
+              pos__ = (pos__ + 1);
+              for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+                current_statement__ = 6;
+                assign(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(3), nil_index_list())),
+                  b_flat__[(pos__ - 1)], "assigning variable b");
+                current_statement__ = 6;
+                pos__ = (pos__ + 1);}
+            } 
           }
           {
-            {
-              {
-                {
-                  {
-                    vars__.push_back(
-                      rvalue(x_matrix,
-                        cons_list(index_uni(1),
-                          cons_list(index_uni(2), nil_index_list())),
-                        "x_matrix"));
-                  }
-                  {
-                    {
-                      vars__.push_back(
-                        rvalue(x_matrix,
-                          cons_list(index_uni(2),
-                            cons_list(index_uni(2), nil_index_list())),
-                          "x_matrix"));
-                    }
-                  }
-                  {
-                    {
-                      vars__.push_back(
-                        rvalue(x_matrix,
-                          cons_list(index_uni(3),
-                            cons_list(index_uni(2), nil_index_list())),
-                          "x_matrix"));
-                    }
-                  }
-                }
-              }
-            }
+            current_statement__ = 6;
+            if (lcm_sym1__) {
+              current_statement__ = 6;
+              assign(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(4), nil_index_list())),
+                b_flat__[(pos__ - 1)], "assigning variable b");
+              current_statement__ = 6;
+              pos__ = (pos__ + 1);
+              for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+                current_statement__ = 6;
+                assign(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(4), nil_index_list())),
+                  b_flat__[(pos__ - 1)], "assigning variable b");
+                current_statement__ = 6;
+                pos__ = (pos__ + 1);}
+            } 
           }
-        }
-      }
-      {
-        {
           {
-            vars__.push_back(
-              rvalue(x_vector, cons_list(index_uni(1), nil_index_list()),
-                "x_vector"));
+            current_statement__ = 6;
+            if (lcm_sym1__) {
+              current_statement__ = 6;
+              assign(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(5), nil_index_list())),
+                b_flat__[(pos__ - 1)], "assigning variable b");
+              current_statement__ = 6;
+              pos__ = (pos__ + 1);
+              for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+                current_statement__ = 6;
+                assign(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(5), nil_index_list())),
+                  b_flat__[(pos__ - 1)], "assigning variable b");
+                current_statement__ = 6;
+                pos__ = (pos__ + 1);}
+            } 
           }
           {
-            {
-              vars__.push_back(
-                rvalue(x_vector, cons_list(index_uni(2), nil_index_list()),
-                  "x_vector"));
-            }
+            current_statement__ = 6;
+            if (lcm_sym1__) {
+              current_statement__ = 6;
+              assign(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(6), nil_index_list())),
+                b_flat__[(pos__ - 1)], "assigning variable b");
+              current_statement__ = 6;
+              pos__ = (pos__ + 1);
+              for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+                current_statement__ = 6;
+                assign(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(6), nil_index_list())),
+                  b_flat__[(pos__ - 1)], "assigning variable b");
+                current_statement__ = 6;
+                pos__ = (pos__ + 1);}
+            } 
+          }
+          {
+            current_statement__ = 6;
+            if (lcm_sym1__) {
+              current_statement__ = 6;
+              assign(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(7), nil_index_list())),
+                b_flat__[(pos__ - 1)], "assigning variable b");
+              current_statement__ = 6;
+              pos__ = (pos__ + 1);
+              for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+                current_statement__ = 6;
+                assign(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(7), nil_index_list())),
+                  b_flat__[(pos__ - 1)], "assigning variable b");
+                current_statement__ = 6;
+                pos__ = (pos__ + 1);}
+            } 
+          }
+          {
+            current_statement__ = 6;
+            if (lcm_sym1__) {
+              current_statement__ = 6;
+              assign(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(8), nil_index_list())),
+                b_flat__[(pos__ - 1)], "assigning variable b");
+              current_statement__ = 6;
+              pos__ = (pos__ + 1);
+              for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+                current_statement__ = 6;
+                assign(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(8), nil_index_list())),
+                  b_flat__[(pos__ - 1)], "assigning variable b");
+                current_statement__ = 6;
+                pos__ = (pos__ + 1);}
+            } 
           }
         }
       }
+      vars__.push_back(alpha0);
+      vars__.push_back(alpha1);
+      vars__.push_back(alpha2);
+      vars__.push_back(alpha12);
+      vars__.push_back(tau);
       {
+        lcm_sym1__ = logical_gte(I, 1);
+        if (lcm_sym1__) {
+          vars__.push_back(
+            rvalue(b,
+              cons_list(index_uni(1),
+                cons_list(index_uni(1), nil_index_list())), "b"));
+          for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(sym2__),
+                  cons_list(index_uni(1), nil_index_list())), "b"));}
+        } 
         {
-          {
+          if (lcm_sym1__) {
             vars__.push_back(
-              rvalue(x_cov_free__, cons_list(index_uni(1), nil_index_list()),
-                "x_cov_free__"));
-          }
-          {
-            {
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(2), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
               vars__.push_back(
-                rvalue(x_cov_free__,
-                  cons_list(index_uni(2), nil_index_list()), "x_cov_free__"));
-            }
-          }
-          {
-            {
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(2), nil_index_list())), "b"));}
+          } 
+        }
+        {
+          if (lcm_sym1__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(3), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
               vars__.push_back(
-                rvalue(x_cov_free__,
-                  cons_list(index_uni(3), nil_index_list()), "x_cov_free__"));
-            }
-          }
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(3), nil_index_list())), "b"));}
+          } 
+        }
+        {
+          if (lcm_sym1__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(4), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              vars__.push_back(
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(4), nil_index_list())), "b"));}
+          } 
+        }
+        {
+          if (lcm_sym1__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(5), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              vars__.push_back(
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(5), nil_index_list())), "b"));}
+          } 
+        }
+        {
+          if (lcm_sym1__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(6), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              vars__.push_back(
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(6), nil_index_list())), "b"));}
+          } 
+        }
+        {
+          if (lcm_sym1__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(7), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              vars__.push_back(
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(7), nil_index_list())), "b"));}
+          } 
+        }
+        {
+          if (lcm_sym1__) {
+            vars__.push_back(
+              rvalue(b,
+                cons_list(index_uni(1),
+                  cons_list(index_uni(8), nil_index_list())), "b"));
+            for (int sym2__ = 2; sym2__ <= I; ++sym2__) {
+              vars__.push_back(
+                rvalue(b,
+                  cons_list(index_uni(sym2__),
+                    cons_list(index_uni(8), nil_index_list())), "b"));}
+          } 
         }
       }
     } catch (const std::exception& e) {
@@ -1689,11 +33492,13 @@ class optimizations_model : public model_base_crtp<optimizations_model> {
   inline void get_param_names(std::vector<std::string>& names__) const {
     
     names__.resize(0);
-    names__.push_back("theta");
-    names__.push_back("phi");
-    names__.push_back("x_matrix");
-    names__.push_back("x_vector");
-    names__.push_back("x_cov");
+    names__.push_back("alpha0");
+    names__.push_back("alpha1");
+    names__.push_back("alpha2");
+    names__.push_back("alpha12");
+    names__.push_back("tau");
+    names__.push_back("b");
+    names__.push_back("sigma");
     } // get_param_names() 
     
   inline void get_dims(std::vector<std::vector<size_t>>& dimss__) const {
@@ -1703,17 +33508,17 @@ class optimizations_model : public model_base_crtp<optimizations_model> {
     dims__.resize(0);
     dimss__.push_back(dims__);
     dims__.resize(0);
-    dims__.push_back(3);
-    
-    dims__.push_back(2);
     dimss__.push_back(dims__);
     dims__.resize(0);
-    dims__.push_back(2);
     dimss__.push_back(dims__);
     dims__.resize(0);
-    dims__.push_back(2);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
+    dims__.push_back(I);
     
-    dims__.push_back(2);
+    dims__.push_back(K);
+    dimss__.push_back(dims__);
+    dims__.resize(0);
     dimss__.push_back(dims__);
     dims__.resize(0);
     
@@ -1724,28 +33529,20 @@ class optimizations_model : public model_base_crtp<optimizations_model> {
                                       bool emit_transformed_parameters__ = true,
                                       bool emit_generated_quantities__ = true) const {
     
-    param_names__.push_back(std::string() + "theta");
-    param_names__.push_back(std::string() + "phi");
-    for (int sym111__ = 1; sym111__ <= 2; ++sym111__) {
+    param_names__.push_back(std::string() + "alpha0");
+    param_names__.push_back(std::string() + "alpha1");
+    param_names__.push_back(std::string() + "alpha2");
+    param_names__.push_back(std::string() + "alpha12");
+    param_names__.push_back(std::string() + "tau");
+    for (int sym39__ = 1; sym39__ <= K; ++sym39__) {
       {
-        for (int sym112__ = 1; sym112__ <= 3; ++sym112__) {
+        for (int sym40__ = 1; sym40__ <= I; ++sym40__) {
           {
-            param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym112__) + '.' + std::to_string(sym111__));
-          }}
-      }}
-    for (int sym111__ = 1; sym111__ <= 2; ++sym111__) {
-      {
-        param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym111__));
-      }}
-    for (int sym111__ = 1; sym111__ <= 2; ++sym111__) {
-      {
-        for (int sym112__ = 1; sym112__ <= 2; ++sym112__) {
-          {
-            param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym112__) + '.' + std::to_string(sym111__));
+            param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym40__) + '.' + std::to_string(sym39__));
           }}
       }}
     if (emit_transformed_parameters__) {
-      
+      param_names__.push_back(std::string() + "sigma");
     }
     
     if (emit_generated_quantities__) {
@@ -1759,25 +33556,20 @@ class optimizations_model : public model_base_crtp<optimizations_model> {
                                         bool emit_transformed_parameters__ = true,
                                         bool emit_generated_quantities__ = true) const {
     
-    param_names__.push_back(std::string() + "theta");
-    param_names__.push_back(std::string() + "phi");
-    for (int sym111__ = 1; sym111__ <= 2; ++sym111__) {
+    param_names__.push_back(std::string() + "alpha0");
+    param_names__.push_back(std::string() + "alpha1");
+    param_names__.push_back(std::string() + "alpha2");
+    param_names__.push_back(std::string() + "alpha12");
+    param_names__.push_back(std::string() + "tau");
+    for (int sym39__ = 1; sym39__ <= K; ++sym39__) {
       {
-        for (int sym112__ = 1; sym112__ <= 3; ++sym112__) {
+        for (int sym40__ = 1; sym40__ <= I; ++sym40__) {
           {
-            param_names__.push_back(std::string() + "x_matrix" + '.' + std::to_string(sym112__) + '.' + std::to_string(sym111__));
+            param_names__.push_back(std::string() + "b" + '.' + std::to_string(sym40__) + '.' + std::to_string(sym39__));
           }}
       }}
-    for (int sym111__ = 1; sym111__ <= 2; ++sym111__) {
-      {
-        param_names__.push_back(std::string() + "x_vector" + '.' + std::to_string(sym111__));
-      }}
-    for (int sym111__ = 1; sym111__ <= 3; ++sym111__) {
-      {
-        param_names__.push_back(std::string() + "x_cov" + '.' + std::to_string(sym111__));
-      }}
     if (emit_transformed_parameters__) {
-      
+      param_names__.push_back(std::string() + "sigma");
     }
     
     if (emit_generated_quantities__) {
@@ -1788,13 +33580,13 @@ class optimizations_model : public model_base_crtp<optimizations_model> {
     
   inline std::string get_constrained_sizedtypes() const {
     stringstream s__;
-    s__ << "[{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"x_matrix\",\"type\":{\"name\":\"matrix\",\"rows\":" << 3 << ",\"cols\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_vector\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_cov\",\"type\":{\"name\":\"matrix\",\"rows\":" << 2 << ",\"cols\":" << 2 << "},\"block\":\"parameters\"}]";
+    s__ << "[{\"name\":\"alpha0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha12\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"tau\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"array\",\"length\":" << I << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]";
     return s__.str();
     } // get_constrained_sizedtypes() 
     
   inline std::string get_unconstrained_sizedtypes() const {
     stringstream s__;
-    s__ << "[{\"name\":\"theta\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"phi\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"x_matrix\",\"type\":{\"name\":\"matrix\",\"rows\":" << 3 << ",\"cols\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_vector\",\"type\":{\"name\":\"vector\",\"length\":" << 2 << "},\"block\":\"parameters\"},{\"name\":\"x_cov\",\"type\":{\"name\":\"vector\",\"length\":" << 3 << "},\"block\":\"parameters\"}]";
+    s__ << "[{\"name\":\"alpha0\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha1\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha2\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"alpha12\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"tau\",\"type\":{\"name\":\"real\"},\"block\":\"parameters\"},{\"name\":\"b\",\"type\":{\"name\":\"array\",\"length\":" << I << ",\"element_type\":{\"name\":\"vector\",\"length\":" << K << "}},\"block\":\"parameters\"},{\"name\":\"sigma\",\"type\":{\"name\":\"real\"},\"block\":\"transformed_parameters\"}]";
     return s__.str();
     } // get_unconstrained_sizedtypes() 
     
@@ -1843,7 +33635,7 @@ class optimizations_model : public model_base_crtp<optimizations_model> {
 
 };
 }
-typedef optimizations_model_namespace::optimizations_model stan_model;
+typedef stalled1_failure_model_namespace::stalled1_failure_model stan_model;
 
 #ifndef USING_R
 
@@ -1860,3 +33652,169 @@ stan::model::model_base& new_model(
 
 
 
+
+Warning: deprecated language construct used in 'stalled1-failure.stan', line 1, column 0:
+   -------------------------------------------------
+     1:  # Using Data Cloning to Calculate MLEs for the Seeds Model in vol1 
+         ^
+     2:  # http://www.openbugs.net/Examples/DataCloning.html
+     3:  
+   -------------------------------------------------
+
+Comments beginning with # are deprecated. Please use // in place of # for line comments.
+
+
+Warning: deprecated language construct used in 'stalled1-failure.stan', line 2, column 0:
+   -------------------------------------------------
+     1:  # Using Data Cloning to Calculate MLEs for the Seeds Model in vol1 
+     2:  # http://www.openbugs.net/Examples/DataCloning.html
+         ^
+     3:  
+     4:  # The basic idea is that we raise the likelihood in the 
+   -------------------------------------------------
+
+Comments beginning with # are deprecated. Please use // in place of # for line comments.
+
+
+Warning: deprecated language construct used in 'stalled1-failure.stan', line 4, column 0:
+   -------------------------------------------------
+     2:  # http://www.openbugs.net/Examples/DataCloning.html
+     3:  
+     4:  # The basic idea is that we raise the likelihood in the 
+         ^
+     5:  # posterior to the power of K so that the posterior
+     6:  # estimates would concentrate on the MLE estimates. 
+   -------------------------------------------------
+
+Comments beginning with # are deprecated. Please use // in place of # for line comments.
+
+
+Warning: deprecated language construct used in 'stalled1-failure.stan', line 5, column 0:
+   -------------------------------------------------
+     3:  
+     4:  # The basic idea is that we raise the likelihood in the 
+     5:  # posterior to the power of K so that the posterior
+         ^
+     6:  # estimates would concentrate on the MLE estimates. 
+     7:  # Reference: 
+   -------------------------------------------------
+
+Comments beginning with # are deprecated. Please use // in place of # for line comments.
+
+
+Warning: deprecated language construct used in 'stalled1-failure.stan', line 6, column 0:
+   -------------------------------------------------
+     4:  # The basic idea is that we raise the likelihood in the 
+     5:  # posterior to the power of K so that the posterior
+     6:  # estimates would concentrate on the MLE estimates. 
+         ^
+     7:  # Reference: 
+     8:  #   Ecology Letters
+   -------------------------------------------------
+
+Comments beginning with # are deprecated. Please use // in place of # for line comments.
+
+
+Warning: deprecated language construct used in 'stalled1-failure.stan', line 7, column 0:
+   -------------------------------------------------
+     5:  # posterior to the power of K so that the posterior
+     6:  # estimates would concentrate on the MLE estimates. 
+     7:  # Reference: 
+         ^
+     8:  #   Ecology Letters
+     9:  #   Subhash R. Lele Brian Dennis Frithjof Lutscher
+   -------------------------------------------------
+
+Comments beginning with # are deprecated. Please use // in place of # for line comments.
+
+
+Warning: deprecated language construct used in 'stalled1-failure.stan', line 8, column 0:
+   -------------------------------------------------
+     6:  # estimates would concentrate on the MLE estimates. 
+     7:  # Reference: 
+     8:  #   Ecology Letters
+         ^
+     9:  #   Subhash R. Lele Brian Dennis Frithjof Lutscher
+    10:  #   DOI: 10.1111/j.1461-0248.2007.01047.x
+   -------------------------------------------------
+
+Comments beginning with # are deprecated. Please use // in place of # for line comments.
+
+
+Warning: deprecated language construct used in 'stalled1-failure.stan', line 9, column 0:
+   -------------------------------------------------
+     7:  # Reference: 
+     8:  #   Ecology Letters
+     9:  #   Subhash R. Lele Brian Dennis Frithjof Lutscher
+         ^
+    10:  #   DOI: 10.1111/j.1461-0248.2007.01047.x
+    11:  #   http://onlinelibrary.wiley.com/doi/10.1111/j.1461-0248.2007.01047.x/abstract
+   -------------------------------------------------
+
+Comments beginning with # are deprecated. Please use // in place of # for line comments.
+
+
+Warning: deprecated language construct used in 'stalled1-failure.stan', line 10, column 0:
+   -------------------------------------------------
+     8:  #   Ecology Letters
+     9:  #   Subhash R. Lele Brian Dennis Frithjof Lutscher
+    10:  #   DOI: 10.1111/j.1461-0248.2007.01047.x
+         ^
+    11:  #   http://onlinelibrary.wiley.com/doi/10.1111/j.1461-0248.2007.01047.x/abstract
+    12:  
+   -------------------------------------------------
+
+Comments beginning with # are deprecated. Please use // in place of # for line comments.
+
+
+Warning: deprecated language construct used in 'stalled1-failure.stan', line 11, column 0:
+   -------------------------------------------------
+     9:  #   Subhash R. Lele Brian Dennis Frithjof Lutscher
+    10:  #   DOI: 10.1111/j.1461-0248.2007.01047.x
+    11:  #   http://onlinelibrary.wiley.com/doi/10.1111/j.1461-0248.2007.01047.x/abstract
+         ^
+    12:  
+    13:  
+   -------------------------------------------------
+
+Comments beginning with # are deprecated. Please use // in place of # for line comments.
+
+
+Warning: deprecated language construct used in 'stalled1-failure.stan', line 25, column 7:
+   -------------------------------------------------
+    23:      int K; 
+    24:      vector[I] x1x2;
+    25:      K <- 8; // {1, 2, 4, 8, 16, 32, 64, 128, 256}
+                ^
+    26:      x1x2 <- x1 .* x2;
+    27:  } 
+   -------------------------------------------------
+
+assignment operator <- is deprecated in the Stan language; use = instead.
+
+
+Warning: deprecated language construct used in 'stalled1-failure.stan', line 26, column 10:
+   -------------------------------------------------
+    24:      vector[I] x1x2;
+    25:      K <- 8; // {1, 2, 4, 8, 16, 32, 64, 128, 256}
+    26:      x1x2 <- x1 .* x2;
+                   ^
+    27:  } 
+    28:  
+   -------------------------------------------------
+
+assignment operator <- is deprecated in the Stan language; use = instead.
+
+
+Warning: deprecated language construct used in 'stalled1-failure.stan', line 40, column 11:
+   -------------------------------------------------
+    38:  transformed parameters {
+    39:      real sigma; 
+    40:      sigma <- 1 / sqrt(tau); 
+                    ^
+    41:  } 
+    42:  
+   -------------------------------------------------
+
+assignment operator <- is deprecated in the Stan language; use = instead.
+
diff --git a/test/integration/good/compiler-optimizations/dce-fail.stan b/test/integration/good/compiler-optimizations/dce-fail.stan
new file mode 100644
index 0000000000..196819a222
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/dce-fail.stan
@@ -0,0 +1,71 @@
+data {
+  int<lower=0> N;
+  int<lower=0> n_age;
+  int<lower=0> n_edu;
+  int<lower=0> n_region;
+  int<lower=0> n_state;
+
+  int<lower=0, upper=1> female[N];
+  int<lower=0, upper=1> black[N];
+  int<lower=0, upper=n_age> age[N];
+  int<lower=0, upper=n_edu> edu[N];
+  int<lower=0, upper=n_state> region[n_state];
+  int<lower=0, upper=n_state> state[N];
+  int<lower=0, upper=1> y[N];
+  vector[n_state] v_prev;
+}
+parameters {
+  real<lower=0> sigma;
+  real<lower=0> sigma_age;
+  real<lower=0> sigma_edu;
+  real<lower=0> sigma_state;
+  real<lower=0> sigma_region;
+  real<lower=0> sigma_age_edu;
+
+  real b_0;
+  real b_female;
+  real b_black;
+  real b_female_black;
+
+  real b_v_prev;
+
+  vector[n_age] b_age;
+  vector[n_edu] b_edu;
+  vector[n_region] b_region;
+  matrix[n_age,n_edu] b_age_edu;
+
+  vector[n_state] b_hat;
+}
+model {
+  vector[N] p;
+  vector[n_state] b_state_hat;
+
+  b_0 ~ normal(0, 100);
+  b_female ~ normal(0, 100);
+  b_black ~ normal(0, 100);
+  b_female_black ~ normal(0, 100);
+
+  b_age ~ normal(0, sigma_age);
+  b_edu ~ normal(0, sigma_edu);
+  b_region ~ normal(0, sigma_region);
+
+  for (j in 1:n_age) {
+    for (i in 1:n_edu)
+      b_age_edu[j,i] ~ normal(0, sigma_age_edu);
+  }
+
+  b_v_prev ~ normal(0, 100);
+
+  for (j in 1:n_state)
+    b_state_hat[j] = b_region[region[j]] + b_v_prev * v_prev[j];
+
+  b_hat ~ normal(b_state_hat, sigma_state);
+
+  for (i in 1:N)
+    p[i] = fmax(0, fmin(1, inv_logit(b_0 + b_female*female[i] 
+      + b_black*black[i] + b_female_black*female[i]*black[i] +
+      b_age[age[i]] + b_edu[edu[i]] + b_age_edu[age[i],edu[i]] +
+      b_hat[state[i]])));
+
+  y ~ bernoulli(p);
+}
diff --git a/test/integration/good/compiler-optimizations/dune b/test/integration/good/compiler-optimizations/dune
index f4d4d7da5b..ba32bbdeb2 100644
--- a/test/integration/good/compiler-optimizations/dune
+++ b/test/integration/good/compiler-optimizations/dune
@@ -1,6 +1,30 @@
 (rule
  (targets cpp.output)
- (deps (package stanc) (:stanfiles optimizations.stan))
+ (deps (package stanc) (:stanfiles
+   optimizations.stan
+   expr-prop-fail8.stan
+   lcm-experiment2.stan
+   expr-prop-fail7.stan
+   expr-prop-experiment2.stan
+   lcm-experiment.stan
+   expr-prop-fail6.stan
+   expr-prop-experiment.stan
+   expr-prop-fail5.stan
+   expr-prop-fail4.stan
+   lcm-fails2.stan
+   lcm-fails.stan
+   expr-prop-fail3.stan
+   expr-prop-fail2.stan
+   inlining-fail2.stan
+   dce-fail.stan
+   partial-eval.stan
+   copy_fail.stan
+   fails-test.stan
+   off-small.stan
+   off-dce.stan
+   stalled1-failure.stan
+   expr-prop-fail.stan
+   ad-level-failing.stan))
  (action
   (with-stdout-to %{targets}
    (run %{bin:run_bin_on_args} "%{bin:stanc} --O --print-cpp" %{stanfiles}))))
diff --git a/test/integration/good/compiler-optimizations/expr-prop-experiment.stan b/test/integration/good/compiler-optimizations/expr-prop-experiment.stan
new file mode 100644
index 0000000000..448f3ff717
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/expr-prop-experiment.stan
@@ -0,0 +1,15 @@
+data {
+  int j;
+}
+transformed data {
+  real z;
+  real x;
+  real y;
+  real i = normal_rng(5, 1);
+  z = i * j; 
+  x = normal_rng(z, 1);
+  i = normal_rng(5, 1);
+  y = normal_rng(z, 1);
+}
+model {
+}
diff --git a/test/integration/good/compiler-optimizations/expr-prop-experiment2.stan b/test/integration/good/compiler-optimizations/expr-prop-experiment2.stan
new file mode 100644
index 0000000000..d6b9dadee6
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/expr-prop-experiment2.stan
@@ -0,0 +1,15 @@
+data {
+  int j;
+}
+transformed data {
+  real z = 1;
+  real y;
+  {
+    real x = normal_rng(123, 1);
+    z = x * 2;
+    y = normal_rng(z, 1);
+  }
+  y = normal_rng(z, 1);
+}
+model {
+}
diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail.stan b/test/integration/good/compiler-optimizations/expr-prop-fail.stan
new file mode 100644
index 0000000000..02e45fc3f2
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/expr-prop-fail.stan
@@ -0,0 +1,20 @@
+data {
+ int<lower = 0> N;
+ vector[N] y;
+}
+
+parameters {
+  ordered[2] mu;
+  real<lower=0> sigma[2];
+  real<lower=0, upper=1> theta;
+}
+
+model {
+ sigma ~ normal(0, 2);
+ mu ~ normal(0, 2);
+ theta ~ beta(5, 5);
+ for (n in 1:N)
+   target += log_mix(theta,
+                     normal_lpdf(y[n] | mu[1], sigma[1]),
+                     normal_lpdf(y[n] | mu[2], sigma[2]));
+}
diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail2.stan b/test/integration/good/compiler-optimizations/expr-prop-fail2.stan
new file mode 100644
index 0000000000..d8101c7274
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/expr-prop-fail2.stan
@@ -0,0 +1,14 @@
+data {
+  int<lower=0> J;          // number of schools
+  real y[J];               // estimated treatment effect (school j)
+  real<lower=0> sigma[J];  // std err of effect estimate (school j)
+}
+parameters {
+  real mu;
+  real theta[J];
+  real<lower=0> tau;
+}
+model {
+  theta ~ normal(mu, tau); 
+  y ~ normal(theta,sigma);
+}
diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail3.stan b/test/integration/good/compiler-optimizations/expr-prop-fail3.stan
new file mode 100644
index 0000000000..fb1643e192
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/expr-prop-fail3.stan
@@ -0,0 +1,48 @@
+data {
+  int<lower=0> N; 
+  int<lower=0> n_age;
+  int<lower=0> n_age_edu;  
+  int<lower=0> n_edu; 
+  int<lower=0> n_region_full; 
+  int<lower=0> n_state; 
+  int<lower=0,upper=n_age> age[N];
+  int<lower=0,upper=n_age_edu> age_edu[N];
+  vector<lower=0,upper=1>[N] black;
+  int<lower=0,upper=n_edu> edu[N];
+  vector<lower=0,upper=1>[N] female;
+  int<lower=0,upper=n_region_full> region_full[N];
+  int<lower=0,upper=n_state> state[N];
+  vector[N] v_prev_full;
+  int<lower=0,upper=1> y[N];
+} 
+parameters {
+  vector[n_age] a;
+  vector[n_edu] b;
+  vector[n_age_edu] c;
+  vector[n_state] d;
+  vector[n_region_full] e;
+  vector[5] beta;
+  real<lower=0,upper=100> sigma_a;
+  real<lower=0,upper=100> sigma_b;
+  real<lower=0,upper=100> sigma_c;
+  real<lower=0,upper=100> sigma_d;
+  real<lower=0,upper=100> sigma_e;
+}
+transformed parameters {
+  vector[N] y_hat;
+
+  for (i in 1:N)
+    y_hat[i] = beta[1] + beta[2] * black[i] + beta[3] * female[i]
+                + beta[5] * female[i] * black[i] 
+                + beta[4] * v_prev_full[i] + a[age[i]] + b[edu[i]] 
+                + c[age_edu[i]] + d[state[i]] + e[region_full[i]];
+} 
+model {
+  a ~ normal (0, sigma_a);
+  b ~ normal (0, sigma_b);
+  c ~ normal (0, sigma_c);
+  d ~ normal (0, sigma_d);
+  e ~ normal (0, sigma_e);
+  beta ~ normal(0, 100);
+  y ~ bernoulli_logit(y_hat);
+}
diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail4.stan b/test/integration/good/compiler-optimizations/expr-prop-fail4.stan
new file mode 100644
index 0000000000..524e12a47c
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/expr-prop-fail4.stan
@@ -0,0 +1,50 @@
+data {
+  int<lower=0> N;
+  int<lower=0> N_edges;
+  int<lower=1, upper=N> node1[N_edges];  // node1[i] adjacent to node2[i]
+  int<lower=1, upper=N> node2[N_edges];  // and node1[i] < node2[i]
+  vector<lower=0>[N] E;           // exposure
+}
+transformed data {
+  vector[N] log_E = log(E);
+}
+parameters {
+  real<lower=0> tau_phi;     // precision of spatial effects
+  vector[N - 1] phi_std_raw; // raw, standardized spatial effects
+}
+transformed parameters {
+  real<lower=0> sigma_phi = inv(sqrt(tau_phi));      // convert precision to sigma
+  vector[N] phi;
+  phi[1:(N - 1)] = phi_std_raw;
+  phi[N] = -sum(phi_std_raw);
+  phi = phi * sigma_phi;    // non-centered parameterization
+}
+model {
+  target += -0.5 * dot_self(phi[node1] - phi[node2]);
+  tau_phi ~ gamma(1, 1);            // Carlin WinBUGS priors
+}
+generated quantities {
+  real beta0;                // intercept
+  real beta1;                // slope
+  real<lower=0> tau_theta;   // precision of heterogeneous effects
+  real<lower=0> sigma_theta;
+  vector[N] theta;
+  vector[N] theta_std;
+
+  vector[N] x;
+  int y[N];
+  
+  beta0 = normal_rng(0, 1);
+  beta1 = normal_rng(0, 1);
+  for (i in 1:N) {
+    theta_std[i] = normal_rng(0, 1);
+  }
+  tau_theta = gamma_rng(3.2761, 1.81);  // Carlin WinBUGS priors
+  sigma_theta = inv(sqrt(tau_theta));  // convert precision to sigma
+  theta = theta_std * sigma_theta;         // non-centered parameterization
+
+  for (i in 1:N) {
+    x[i] = normal_rng(0, 1);
+    y[i] = poisson_log_rng(log_E[i] + beta0 + beta1 * x[i] + phi[i] + theta[i]);
+  }
+}
diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail5.stan b/test/integration/good/compiler-optimizations/expr-prop-fail5.stan
new file mode 100644
index 0000000000..91fd21f843
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/expr-prop-fail5.stan
@@ -0,0 +1,127 @@
+// This models is derived from section 12.3 of "Stan Modeling Language
+// User's Guide and Reference Manual"
+
+functions {
+  int first_capture(int[] y_i) {
+    for (k in 1:size(y_i))
+      if (y_i[k])
+        return k;
+    return 0;
+  }
+
+  int last_capture(int[] y_i) {
+    for (k_rev in 0:(size(y_i) - 1)) {
+      // Compoud declaration was enabled in Stan 2.13
+      int k = size(y_i) - k_rev;
+      //      int k;
+      //      k = size(y_i) - k_rev;
+      if (y_i[k])
+        return k;
+    }
+    return 0;
+  }
+
+  matrix prob_uncaptured(int nind, int n_occasions,
+                         matrix p, matrix phi) {
+    matrix[nind, n_occasions] chi;
+
+    for (i in 1:nind) {
+      chi[i, n_occasions] = 1.0;
+      for (t in 1:(n_occasions - 1)) {
+        // Compoud declaration was enabled in Stan 2.13
+        int t_curr = n_occasions - t;
+        int t_next = t_curr + 1;
+        /*
+        int t_curr;
+        int t_next;
+
+        t_curr = n_occasions - t;
+        t_next = t_curr + 1;
+        */
+        t_curr = n_occasions - t;
+        t_next = t_curr + 1;
+        chi[i, t_curr] = (1 - phi[i, t_curr])
+                        + phi[i, t_curr] * (1 - p[i, t_next - 1]) * chi[i, t_next];
+      }
+    }
+    return chi;
+  }
+}
+
+data {
+  int<lower=0> nind;            // Number of individuals
+  int<lower=2> n_occasions;     // Number of capture occasions
+  int<lower=0,upper=1> y[nind, n_occasions];    // Capture-history
+}
+
+transformed data {
+  int n_occ_minus_1 = n_occasions - 1;
+  //  int n_occ_minus_1;
+  int<lower=0,upper=n_occasions> first[nind];
+  int<lower=0,upper=n_occasions> last[nind];
+
+  //  n_occ_minus_1 = n_occasions - 1;
+  for (i in 1:nind)
+    first[i] = first_capture(y[i]);
+  for (i in 1:nind)
+    last[i] = last_capture(y[i]);
+}
+
+parameters {
+  real<lower=0,upper=1> mean_phi;       // Mean survival
+  real<lower=0,upper=1> mean_p;         // Mean recapture
+  vector[nind] epsilon;
+  real<lower=0,upper=5> sigma;
+  // In case a weakly informative prior is used
+  //  real<lower=0> sigma;
+}
+
+transformed parameters {
+  matrix<lower=0,upper=1>[nind, n_occ_minus_1] phi;
+  matrix<lower=0,upper=1>[nind, n_occ_minus_1] p;
+  matrix<lower=0,upper=1>[nind, n_occasions] chi;
+  real mu;
+
+  // Constraints
+  mu = logit(mean_phi);
+  for (i in 1:nind) {
+    for (t in 1:(first[i] - 1)) {
+      phi[i, t] = 0;
+      p[i, t] = 0;
+    }
+    for (t in first[i]:n_occ_minus_1) {
+      phi[i, t] = inv_logit(mu + epsilon[i]);
+      p[i, t] = mean_p;
+    }
+  }
+
+  chi = prob_uncaptured(nind, n_occasions, p, phi);
+}
+
+model {
+  // Priors
+  // Uniform priors are implicitly defined.
+  //  mean_phi ~ uniform(0, 1);
+  //  mean_p ~ uniform(0, 1);
+  //  sigma ~ uniform(0, 5);
+  // In case a weaily informative prior is used
+  //  sigma ~ normal(2.5, 1.25);
+  epsilon ~ normal(0, sigma);
+
+  // Likelihood
+  for (i in 1:nind) {
+    if (first[i] > 0) {
+      for (t in (first[i] + 1):last[i]) {
+        1 ~ bernoulli(phi[i, t - 1]);
+        y[i, t] ~ bernoulli(p[i, t - 1]);
+      }
+      1 ~ bernoulli(chi[i, last[i]]);
+    }
+  }
+}
+
+generated quantities {
+  real<lower=0> sigma2;
+
+  sigma2 = square(sigma);
+}
diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail6.stan b/test/integration/good/compiler-optimizations/expr-prop-fail6.stan
new file mode 100644
index 0000000000..2eefa1c3ba
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/expr-prop-fail6.stan
@@ -0,0 +1,264 @@
+// JS model using the superpopulation parameterization
+
+functions {
+  // These functions are derived from Section 12.3 of
+  // Stan Modeling Language User's Guide and Reference Manual
+
+  /**
+   * Return a integer value of first capture occasion
+   *
+   * @param y_i Integer array of capture history
+   *
+   * @return Integer value of first capture occasion
+   */
+  int first_capture(int[] y_i) {
+    for (k in 1:size(y_i))
+      if (y_i[k])
+        return k;
+    return 0;
+  }
+
+  /**
+   * Return a integer value of last capture occasion
+   *
+   * @param y_i Integer array of capture history
+   *
+   * @return Integer value of last capture occasion
+   */
+  int last_capture(int[] y_i) {
+    for (k_rev in 0:(size(y_i) - 1)) {
+      int k = size(y_i) - k_rev;
+
+      if (y_i[k])
+        return k;
+    }
+    return 0;
+  }
+
+  /**
+   * Return a matrix of uncaptured probabilities
+   *
+   * @param p   Matrix of detection probabilities for each individual
+   *            and capture occasion
+   * @param phi Matrix of survival probabilities for each individual
+   *            and capture occasion
+   *
+   * @return Matrix of uncaptured probabilities
+   */
+  matrix prob_uncaptured(matrix p, matrix phi) {
+    int n_ind = rows(p);
+    int n_occasions = cols(p);
+    matrix[n_ind, n_occasions] chi;
+
+    for (i in 1:n_ind) {
+      chi[i, n_occasions] = 1.0;
+      for (t in 1:(n_occasions - 1)) {
+        int t_curr = n_occasions - t;
+        int t_next = t_curr + 1;
+
+        chi[i, t_curr] = (1 - phi[i, t_curr])
+          + phi[i, t_curr] * (1 - p[i, t_next]) * chi[i, t_next];
+      }
+    }
+    return chi;
+  }
+
+  /**
+   * Calculate log likelihood of a Jolly-Seber model
+   * under the superpopulation parameterization
+   *
+   * @param y     Integer array of capture history
+   * @param first Integer array of first capture occasions
+   * @param last  Integer array of last capture occasions
+   * @param p     Matrix of detection probabilities
+   * @param phi   Matrix of survival probabilities
+   * @param psi   Real value of inclusion probability
+   * @param nu    Vector of entry probabilities
+   * @param chi   Matrix of uncapture probabilities
+   */
+  void js_super_lp(int[,] y, int[] first, int[] last,
+                   matrix p, matrix phi, real psi,
+                   vector nu, matrix chi) {
+    int n_ind = dims(y)[1];
+    int n_occasions = dims(y)[2];
+    vector[n_occasions] qnu = 1.0 - nu;
+
+    for (i in 1:n_ind) {
+      vector[n_occasions] qp = 1.0 - p[i]';
+
+      if (first[i]) { // Observed
+        // Included
+        1 ~ bernoulli(psi);
+
+        // Until first capture
+        if (first[i] == 1) {
+          1 ~ bernoulli(nu[1] * p[i, 1]);
+        } else {  // first[i] >= 2
+          vector[first[i]] lp;
+
+          // Entered at 1st occasion
+          lp[1] = bernoulli_lpmf(1 | nu[1])
+                 + bernoulli_lpmf(1 | prod(qp[1:(first[i] - 1)]))
+                 + bernoulli_lpmf(1 | prod(phi[i, 1:(first[i] - 1)]))
+                 + bernoulli_lpmf(1 | p[i, first[i]]);
+          // Entered at t-th occasion (1 < t < first[i])
+          for (t in 2:(first[i] - 1))
+            lp[t] = bernoulli_lpmf(1 | prod(qnu[1:(t - 1)]))
+                   + bernoulli_lpmf(1 | nu[t])
+                   + bernoulli_lpmf(1 | prod(qp[t:(first[i] - 1)]))
+                   + bernoulli_lpmf(1 | prod(phi[i, t:(first[i] - 1)]))
+                   + bernoulli_lpmf(1 | p[i, first[i]]);
+          lp[first[i]] = bernoulli_lpmf(1 | prod(qnu[1:(first[i] - 1)]))
+                        + bernoulli_lpmf(1 | nu[first[i]])
+                        + bernoulli_lpmf(1 | p[i, first[i]]);
+          target += log_sum_exp(lp);
+        }
+        // Until last capture
+        for (t in (first[i] + 1):last[i]) {
+          1 ~ bernoulli(phi[i, t - 1]);   // Survived
+          y[i, t] ~ bernoulli(p[i, t]);   // Capture/Non-capture
+        }
+        // Subsequent occasions
+        1 ~ bernoulli(chi[i, last[i]]);
+      } else {          // Never observed
+        vector[n_occasions+1] lp;
+
+        // Entered at 1st occasion, but never captured
+        lp[1] = bernoulli_lpmf(1 | psi)
+               + bernoulli_lpmf(1 | nu[1])
+               + bernoulli_lpmf(0 | p[i, 1])
+               + bernoulli_lpmf(1 | chi[i, 1]);
+        // Entered at t-th occation (t > 1), but never captured
+        for (t in 2:n_occasions)
+          lp[t] = bernoulli_lpmf(1 | psi)
+                 + bernoulli_lpmf(1 | prod(qnu[1:(t - 1)]))
+                 + bernoulli_lpmf(1 | nu[t])
+                 + bernoulli_lpmf(0 | p[i, t])
+                 + bernoulli_lpmf(1 | chi[i, t]);
+        // Never captured
+        lp[n_occasions + 1] = bernoulli_lpmf(0 | psi);
+        target += log_sum_exp(lp);
+      }
+    }
+  }
+}
+
+data {
+  int<lower=0> M;                              // Augmented sample size
+  int<lower=0> n_occasions;                    // Number of capture occasions
+  int<lower=0,upper=1> y[M, n_occasions];      // Augmented capture-history
+}
+
+transformed data {
+  int<lower=0,upper=n_occasions> first[M];
+  int<lower=0,upper=n_occasions> last[M];
+
+  for (i in 1:M)
+    first[i] = first_capture(y[i]);
+  for (i in 1:M)
+    last[i] = last_capture(y[i]);
+}
+
+parameters {
+  real<lower=0,upper=1> mean_phi;             // Mean survival
+  real<lower=0,upper=1> mean_p;               // Mean capture
+  real<lower=0,upper=1> psi;                  // Inclusion probability
+  vector<lower=0>[n_occasions] beta;
+  vector[M] epsilon;
+  real<lower=0,upper=5> sigma;
+  // In case of using a weakly informative prior
+  //  real<lower=0> sigma;
+}
+
+transformed parameters {
+  matrix<lower=0,upper=1>[M, n_occasions - 1] phi;
+  matrix<lower=0,upper=1>[M, n_occasions] p;
+  simplex[n_occasions] b;                     // Entry probability
+  vector<lower=0,upper=1>[n_occasions] nu;
+  matrix<lower=0,upper=1>[M, n_occasions] chi;
+
+  // Constraints
+  phi = rep_matrix(mean_phi, M, n_occasions - 1);
+  for (t in 1:n_occasions)
+    p[, t] = inv_logit(logit(mean_p) + epsilon);
+
+
+  // Dirichlet prior for entry probabilities
+  // beta ~ gamma(1, 1);  // => model block
+  b = beta / sum(beta);
+
+  // Convert entry probs to conditional entry probs
+  {
+    real cum_b = b[1];
+
+    nu[1] = b[1];
+    for (t in 2:(n_occasions - 1)) {
+      nu[t] = b[t] / (1.0 - cum_b);
+      cum_b = cum_b + b[t];
+    }
+    nu[n_occasions] = 1.0;
+  }
+
+  // Uncaptured probability
+  chi = prob_uncaptured(p, phi);
+}
+
+model {
+  // Priors
+  // Uniform priors are implicitly defined.
+  // In case of using a weakly informative prior on sigma
+  //  sigma ~ normal(2.5, 1.25);
+  epsilon ~ normal(0, sigma);
+  beta ~ gamma(1, 1);
+
+  // Likelihood
+  js_super_lp(y, first, last, p, phi, psi, nu, chi);
+}
+
+generated quantities {
+  real<lower=0> sigma2;
+  int<lower=0> Nsuper;                    // Superpopulation size
+  int<lower=0> N[n_occasions];            // Actual population size
+  int<lower=0> B[n_occasions];            // Number of entries
+  int<lower=0,upper=1> z[M, n_occasions]; // Deflated latent state
+
+  sigma2 = square(sigma);
+
+  // Generate w[] and z[]
+  for (i in 1:M) {
+    int q = 1;
+    if (bernoulli_rng(psi)) {      // Included
+      z[i, 1] = bernoulli_rng(nu[1]);
+      for (t in 2:n_occasions) {
+        q = q * (1 - z[i, t - 1]);
+        z[i, t] = bernoulli_rng(z[i, t - 1] * phi[i, t - 1]
+                                 + q * nu[t]);
+      }
+    } else {                       // Not included
+      z[i, ] = rep_array(0, n_occasions);
+    }
+  }
+
+  // Calculate derived population parameters
+  {
+    int recruit[M, n_occasions] = rep_array(0, M, n_occasions);
+    int Nind[M];
+    int Nalive[M];
+
+    for (i in 1:M) {
+      int f = first_capture(z[i, ]);
+
+      if (f > 0)
+        recruit[i, f] = 1;
+    }
+    for (t in 1:n_occasions) {
+      N[t] = sum(z[, t]);
+      B[t] = sum(recruit[, t]);
+    }
+    for (i in 1:M) {
+      Nind[i] = sum(z[i]);
+      Nalive[i] = (Nind[i] > 0);
+    }
+    Nsuper = sum(Nalive);
+  }
+}
diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail7.stan b/test/integration/good/compiler-optimizations/expr-prop-fail7.stan
new file mode 100644
index 0000000000..336803cdc2
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/expr-prop-fail7.stan
@@ -0,0 +1,47 @@
+/*
+ * Implementation of Dawid and Skene's model for measurement error
+ * among categoical raters.  The model is extended for Bayes fixed priors.
+ * Discrete parameters for category of items marginalized out with their
+ * expectation returned on the log scale in derived quantity log_q_z.
+ *
+ * Dawid, A. P., & Skene, A. M. (1979). Maximum likelihood estimation
+ * of observer error-rates using the EM algorithm. Applied statistics,
+ * 20--28.
+ */
+data {
+  int<lower=2> K;               // number of categories
+  int<lower=1> I;               // number of items
+  int<lower=1> J;               // number of coders
+  int<lower=1,upper=K> y[I,J];  // label for observation n
+  vector<lower=0>[K] alpha;     // prior for prevalence (positive)
+  vector<lower=0>[K] beta[K];   // prior for coder responses (positive)
+}
+parameters {
+  simplex[K] pi;                // prevalence of categories
+  simplex[K] theta[J,K];        // response of anotator j to category k
+}
+model {
+  // log prior:  log p(theta, pi)
+  pi ~ dirichlet(alpha);
+  for (j in 1:J)
+    for (k in 1:K)
+      theta[j, k] ~ dirichlet(beta[k]);
+
+  // log marginal likelihood: log p(y | theta, pi)
+  for (i in 1:I) {
+    vector[K] log_q = log(pi);
+    for (j in 1:J)
+      log_q += to_vector(log(theta[j, , y[i, j]]));
+    target += log_sum_exp(log_q);
+  }
+}
+generated quantities {
+  // normalized log posterior: log Pr[z | y]
+  vector[K] log_Pr_z[I];
+  for (i in 1:I) {
+    vector[K] log_q = log(pi);
+    for (j in 1:J)
+      log_q += to_vector(log(theta[j, , y[i, j]]));
+    log_Pr_z[i] = log_q - log_sum_exp(log_q);
+  }
+}
diff --git a/test/integration/good/compiler-optimizations/expr-prop-fail8.stan b/test/integration/good/compiler-optimizations/expr-prop-fail8.stan
new file mode 100644
index 0000000000..8ed40997e6
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/expr-prop-fail8.stan
@@ -0,0 +1,28 @@
+data {
+  int<lower=0> N;
+  int<lower=0> N_edges;
+  int<lower=1, upper=N> node1[N_edges];  // node1[i] adjacent to node2[i]
+  int<lower=1, upper=N> node2[N_edges];  // and node1[i] < node2[i]
+
+  int<lower=0> y[N];              // count outcomes
+  vector[N] x;                    // predictor
+}
+parameters {
+  real beta0;                // intercept
+  real beta1;                // slope
+
+  real<lower=0> tau_theta;   // precision of heterogeneous effects
+  real<lower=0> tau_phi;     // precision of spatial effects
+
+  vector[N] theta_std;       // standardized heterogeneous effects
+  vector[N] phi_std_raw; // raw, standardized spatial effects
+}
+transformed parameters {
+  real<lower=0> sigma_phi = inv(sqrt(tau_phi));
+  vector[N] phi;
+  phi[1:N] = phi_std_raw;
+  phi = phi * sigma_phi;
+}
+model {
+  target += dot_self(phi[node1]);
+}
diff --git a/test/integration/good/compiler-optimizations/fails-test.stan b/test/integration/good/compiler-optimizations/fails-test.stan
new file mode 100644
index 0000000000..a8742e5b37
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/fails-test.stan
@@ -0,0 +1,111 @@
+// This models is derived from section 12.3 of "Stan Modeling Language
+// User's Guide and Reference Manual"
+
+functions {
+  int first_capture(int[] y_i) {
+    for (k in 1:size(y_i))
+      if (y_i[k])
+        return k;
+    return 0;
+  }
+
+  int last_capture(int[] y_i) {
+    for (k_rev in 0:(size(y_i) - 1)) {
+      // Compoud declaration was enabled in Stan 2.13
+      int k = size(y_i) - k_rev;
+      //      int k;
+      //      k = size(y_i) - k_rev;
+      if (y_i[k])
+        return k;
+    }
+    return 0;
+  }
+
+  matrix prob_uncaptured(int nind, int n_occasions,
+                         matrix p, matrix phi) {
+    matrix[nind, n_occasions] chi;
+
+    for (i in 1:nind) {
+      chi[i, n_occasions] = 1.0;
+      for (t in 1:(n_occasions - 1)) {
+        // Compoud declaration was enabled in Stan 2.13
+        int t_curr = n_occasions - t;
+        int t_next = t_curr + 1;
+        /*
+        int t_curr;
+        int t_next;
+
+        t_curr = n_occasions - t;
+        t_next = t_curr + 1;
+        */
+        chi[i, t_curr] = (1 - phi[i, t_curr])
+                        + phi[i, t_curr] * (1 - p[i, t_next - 1]) * chi[i, t_next];
+      }
+    }
+    return chi;
+  }
+}
+
+data {
+  int<lower=0> nind;            // Number of individuals
+  int<lower=2> n_occasions;     // Number of capture occasions
+  int<lower=0,upper=1> y[nind, n_occasions];    // Capture-history
+  int<lower=1> max_age;         // Maximum age
+  int<lower=0,upper=max_age> x[nind, n_occasions - 1];  // Age
+}
+
+transformed data {
+  int n_occ_minus_1 = n_occasions - 1;
+  //  int n_occ_minus_1;
+  int<lower=0,upper=n_occasions> first[nind];
+  int<lower=0,upper=n_occasions> last[nind];
+
+  //  n_occ_minus_1 = n_occasions - 1;
+  for (i in 1:nind)
+    first[i] = first_capture(y[i]);
+  for (i in 1:nind)
+    last[i] = last_capture(y[i]);
+}
+
+parameters {
+  real<lower=0,upper=1> mean_p;           // Mean recapture
+  vector<lower=0,upper=1>[max_age] beta;  // Mean survival
+}
+
+transformed parameters {
+  matrix<lower=0,upper=1>[nind, n_occ_minus_1] phi;   // Survival
+  matrix<lower=0,upper=1>[nind, n_occ_minus_1] p;     // Recapture
+  matrix<lower=0,upper=1>[nind, n_occasions] chi;
+
+  // Constraints
+  for (i in 1:nind) {
+    for (t in 1:(first[i] - 1)) {
+      phi[i, t] = 0;
+      p[i, t] = 0;
+    }
+    for (t in first[i]:n_occ_minus_1) {
+      phi[i, t] = beta[x[i, t]];
+      p[i, t] = mean_p;
+    }
+  }
+
+  chi = prob_uncaptured(nind, n_occasions, p, phi);
+}
+
+model {
+  // Priors
+  // Uniform priors are implicitly defined.
+  //  beta ~ uniform(0, 1);
+  //  mean_p ~ uniform(0, 1);
+
+  // Likelihood
+  for (i in 1:nind) {
+    if (first[i] > 0) {
+      for (t in (first[i] + 1):last[i]) {
+        1 ~ bernoulli(phi[i, t - 1]);
+        y[i, t] ~ bernoulli(p[i, t - 1]);
+      }
+      1 ~ bernoulli(chi[i, last[i]]);
+    }
+  }
+}
diff --git a/test/integration/good/compiler-optimizations/inlining-fail2.stan b/test/integration/good/compiler-optimizations/inlining-fail2.stan
new file mode 100644
index 0000000000..4bcbdb310f
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/inlining-fail2.stan
@@ -0,0 +1,262 @@
+// Jolly-Seber model as a restricted occupancy model
+
+functions {
+  // These functions are derived from Section 12.3 of
+  // Stan Modeling Language User's Guide and Reference Manual
+
+  /**
+   * Return a integer value of first capture occasion
+   *
+   * @param y_i Integer array of capture history
+   *
+   * @return Integer value of first capture occasion
+   */
+  int first_capture(int[] y_i) {
+    for (k in 1:size(y_i))
+      if (y_i[k])
+        return k;
+    return 0;
+  }
+
+  /**
+   * Return a integer value of last capture occasion
+   *
+   * @param y_i Integer array of capture history
+   *
+   * @return Integer value of last capture occasion
+   */
+  int last_capture(int[] y_i) {
+    for (k_rev in 0:(size(y_i) - 1)) {
+      int k = size(y_i) - k_rev;
+
+      if (y_i[k])
+        return k;
+    }
+    return 0;
+  }
+
+  /**
+   * Return a matrix of uncaptured probabilities
+   *
+   * @param p   Matrix of detection probabilities for each individual
+   *            and capture occasion
+   * @param phi Matrix of survival probabilities for each individual
+   *            and capture occasion
+   *
+   * @return Matrix of uncaptured probabilities
+   */
+  matrix prob_uncaptured(matrix p, matrix phi) {
+    int n_ind = rows(p);
+    int n_occasions = cols(p);
+    matrix[n_ind, n_occasions] chi;
+
+    for (i in 1:n_ind) {
+      chi[i, n_occasions] = 1.0;
+      for (t in 1:(n_occasions - 1)) {
+        int t_curr = n_occasions - t;
+        int t_next = t_curr + 1;
+
+        chi[i, t_curr] = (1 - phi[i, t_curr])
+          + phi[i, t_curr] * (1 - p[i, t_next]) * chi[i, t_next];
+      }
+    }
+    return chi;
+  }
+
+  /**
+   * Calculate log likelihood of a Jolly-Seber model
+   *
+   * @param y     Integer array of capture history
+   * @param first Integer array of first capture occasions
+   * @param last  Integer array of last capture occasions
+   * @param p     Matrix of detection probabilities
+   * @param phi   Matrix of survival probabilities
+   * @param gamma Vector of removal entry probabilities
+   * @param chi   Matrix of uncapture probabilities
+   */
+  void jolly_seber_lp(int[,] y, int[] first, int[] last,
+                      matrix p, matrix phi, vector gamma,
+                      matrix chi) {
+    int n_ind = dims(y)[1];
+    int n_occasions = dims(y)[2];
+    vector[n_occasions] qgamma = 1.0 - gamma;
+
+    for (i in 1:n_ind) {
+      vector[n_occasions] qp = 1.0 - p[i]';
+
+      if (first[i]) { // Captured
+        // Until first capture
+        if (first[i] == 1) {
+          1 ~ bernoulli(gamma[1] * p[i, 1]);
+        } else {
+          vector[first[i]] lp;
+
+          // Entered at 1st occasion
+          lp[1] = bernoulli_lpmf(1 | gamma[1])
+                 + bernoulli_lpmf(1 | prod(qp[1:(first[i] - 1)]))
+                 + bernoulli_lpmf(1 | prod(phi[i, 1:(first[i] - 1)]))
+                 + bernoulli_lpmf(1 | p[i, first[i]]);
+          // Entered at t-th occasion (1 < t < first[i])
+          for (t in 2:(first[i] - 1))
+            lp[t] = bernoulli_lpmf(1 | prod(qgamma[1:(t - 1)]))
+                   + bernoulli_lpmf(1 | gamma[t])
+                   + bernoulli_lpmf(1 | prod(qp[t:(first[i] - 1)]))
+                   + bernoulli_lpmf(1 | prod(phi[i, t:(first[i] - 1)]))
+                   + bernoulli_lpmf(1 | p[i, first[i]]);
+          lp[first[i]] = bernoulli_lpmf(1 | prod(qgamma[1:(first[i] - 1)]))
+                        + bernoulli_lpmf(1 | gamma[first[i]])
+                        + bernoulli_lpmf(1 | p[i, first[i]]);
+          target += log_sum_exp(lp);
+        }
+        // Until last capture
+        for (t in (first[i] + 1):last[i]) {
+          1 ~ bernoulli(phi[i, t - 1]);   // Survived
+          y[i, t] ~ bernoulli(p[i, t]);   // Capture/Non-capture
+        }
+        // Subsequent occasions
+        1 ~ bernoulli(chi[i, last[i]]);
+      } else {         // Never captured
+        vector[n_occasions+1] lp;
+
+        // Entered at 1st occasion, but never captured
+        lp[1] = bernoulli_lpmf(1 | gamma[1])
+               + bernoulli_lpmf(0 | p[i, 1])
+               + bernoulli_lpmf(1 | chi[i, 1]);
+        // Entered at t-th occasion, but never captured
+        for (t in 2:n_occasions)
+          lp[t] = bernoulli_lpmf(1 | prod(qgamma[1:(t - 1)]))
+                 + bernoulli_lpmf(1 | gamma[t])
+                 + bernoulli_lpmf(0 | p[i, t])
+                 + bernoulli_lpmf(1 | chi[i, t]);
+        // Never entered
+        lp[n_occasions + 1] = bernoulli_lpmf(1 | prod(qgamma));
+        target += log_sum_exp(lp);
+      }
+    }
+  }
+
+  /**
+   * Returns delta, where
+   * delta[n] = gamma[n] * PROD_{m < n} (1 - gamma[m])
+   * (Thanks to Dr. Carpenter)
+   *
+   * @param gamma Vector of probability sequence
+   *
+   * @return Vector of complementary probability sequence
+   */
+  vector seq_cprob(vector gamma) {
+    int N = rows(gamma);
+    vector[N] log_cprob;
+    real log_residual_prob = 0;
+
+    for (n in 1:N) {
+      log_cprob[n] = log(gamma[n]) + log_residual_prob;
+      log_residual_prob = log_residual_prob + log(1 - gamma[n]);
+    }
+    return exp(log_cprob);
+  }
+}
+
+data {
+  int<lower=0> M;                              // Augmented sample size
+  int<lower=0> n_occasions;                    // Number of capture occasions
+  int<lower=0,upper=1> y[M, n_occasions];      // Augmented capture-history
+}
+
+transformed data {
+  int<lower=0,upper=n_occasions> first[M];
+  int<lower=0,upper=n_occasions> last[M];
+
+  for (i in 1:M)
+    first[i] = first_capture(y[i]);
+  for (i in 1:M)
+    last[i] = last_capture(y[i]);
+}
+
+parameters {
+  real<lower=0,upper=1> mean_phi;             // Mean survival
+  real<lower=0,upper=1> mean_p;               // Mean capture
+  vector<lower=0,upper=1>[n_occasions] gamma; // Removal entry probability
+  vector[n_occasions-1] epsilon;
+  real<lower=0,upper=5> sigma;
+  // In case of using a weakly informative prior
+  //  real<lower=0> sigma;
+}
+
+transformed parameters {
+  matrix<lower=0,upper=1>[M, n_occasions - 1] phi;
+  matrix<lower=0,upper=1>[M, n_occasions] p;
+  matrix<lower=0,upper=1>[M, n_occasions] chi;
+
+  // Constraints
+  for (t in 1:(n_occasions - 1))
+    for (i in 1:M)
+      phi[i, t] = inv_logit(logit(mean_phi) + epsilon[t]);
+  p = rep_matrix(mean_p, M, n_occasions);
+
+  // Uncaptured probability
+  chi = prob_uncaptured(p, phi);
+}
+
+model {
+  // Priors
+  // Uniform priors are implicitly defined.
+  // In case of using a weakly informative prior on sigma
+  //  sigma ~ normal(2.5, 1.25);
+  epsilon ~ normal(0, sigma);
+
+  // Likelihood
+  jolly_seber_lp(y, first, last, p, phi, gamma, chi);
+}
+
+generated quantities {
+  real sigma2;
+  real psi;                // Inclusion probability
+  vector[n_occasions] b;   // Entry probability
+  int Nsuper;              // Superpopulation size
+  int N[n_occasions];      // Actual population size
+  int B[n_occasions];      // Number of entries
+  int z[M, n_occasions];   // Latent state
+
+  // Generate z[]
+  for (i in 1:M) {
+    int q = 1;
+    real mu2;
+
+    z[i, 1] = bernoulli_rng(gamma[1]);
+    for (t in 2:n_occasions) {
+      q = q * (1 - z[i, t - 1]);
+      mu2 = phi[i, t - 1] * z[i, t - 1]
+           + gamma[t] * q;
+      z[i, t] = bernoulli_rng(mu2);
+    }
+  }
+
+  // Calculate derived population parameters
+  {
+    vector[n_occasions] cprob = seq_cprob(gamma);
+    int recruit[M, n_occasions] = rep_array(0, M, n_occasions);
+    int Nind[M];
+    int Nalive[M];
+
+    sigma2 = square(sigma);
+    psi = sum(cprob);
+    b = cprob / psi;
+
+    for (i in 1:M) {
+      int f = first_capture(z[i, ]);
+
+      if (f > 0)
+        recruit[i, f] = 1;
+    }
+    for (t in 1:n_occasions) {
+      N[t] = sum(z[, t]);
+      B[t] = sum(recruit[, t]);
+    }
+    for (i in 1:M) {
+      Nind[i] = sum(z[i]);
+      Nalive[i] = 1 - !Nind[i];
+    }
+    Nsuper = sum(Nalive);
+  }
+}
diff --git a/test/integration/good/compiler-optimizations/lcm-experiment.stan b/test/integration/good/compiler-optimizations/lcm-experiment.stan
new file mode 100644
index 0000000000..025b36c3e8
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/lcm-experiment.stan
@@ -0,0 +1,14 @@
+data {
+  int j;
+}
+transformed data {
+  real z = 1;
+  real x;
+  {
+    x = normal_rng(123, 1);
+    z = normal_rng(sqrt(j)*2+1, 1);
+  }
+  real i = normal_rng(sqrt(j)*2+1, 1);
+}
+model {
+}
diff --git a/test/integration/good/compiler-optimizations/lcm-experiment2.stan b/test/integration/good/compiler-optimizations/lcm-experiment2.stan
new file mode 100644
index 0000000000..45bb907fda
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/lcm-experiment2.stan
@@ -0,0 +1,12 @@
+parameters {
+  real x;
+}
+model {
+  real y = log(x);
+  for (j in 1:1) {
+    y += 1;
+  }
+  if (1 > 0)
+    y += 1;
+  target += y;
+}
diff --git a/test/integration/good/compiler-optimizations/lcm-fails.stan b/test/integration/good/compiler-optimizations/lcm-fails.stan
new file mode 100644
index 0000000000..b6b9fc5d4d
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/lcm-fails.stan
@@ -0,0 +1,10 @@
+data {
+  int<lower=0> J;          // number of schools
+  real y[J];               // estimated treatment effect (school j)
+}
+parameters {
+  real theta[J];
+}
+model {
+  y ~ normal(theta,1);
+}
diff --git a/test/integration/good/compiler-optimizations/lcm-fails2.stan b/test/integration/good/compiler-optimizations/lcm-fails2.stan
new file mode 100644
index 0000000000..ab5a3ff4a4
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/lcm-fails2.stan
@@ -0,0 +1,109 @@
+// This models is derived from section 12.3 of "Stan Modeling Language
+// User's Guide and Reference Manual"
+
+functions {
+  int first_capture(int[] y_i) {
+    for (k in 1:size(y_i))
+      if (y_i[k])
+        return k;
+    return 0;
+  }
+
+  int last_capture(int[] y_i) {
+    for (k_rev in 0:(size(y_i) - 1)) {
+      // Compoud declaration was enabled in Stan 2.13
+      int k = size(y_i) - k_rev;
+      //      int k;
+      //      k = size(y_i) - k_rev;
+      if (y_i[k])
+        return k;
+    }
+    return 0;
+  }
+
+  matrix prob_uncaptured(int nind, int n_occasions,
+                         matrix p, matrix phi) {
+    matrix[nind, n_occasions] chi;
+
+    for (i in 1:nind) {
+      chi[i, n_occasions] = 1.0;
+      for (t in 1:(n_occasions - 1)) {
+        // Compoud declaration was enabled in Stan 2.13
+        int t_curr = n_occasions - t;
+        int t_next = t_curr + 1;
+        /*
+        int t_curr;
+        int t_next;
+
+        t_curr = n_occasions - t;
+        t_next = t_curr + 1;
+        */
+        chi[i, t_curr] = (1 - phi[i, t_curr])
+                        + phi[i, t_curr] * (1 - p[i, t_next - 1]) * chi[i, t_next];
+      }
+    }
+    return chi;
+  }
+}
+
+data {
+  int<lower=0> nind;            // Number of individuals
+  int<lower=2> n_occasions;     // Number of capture occasions
+  int<lower=0,upper=1> y[nind, n_occasions];    // Capture-history
+}
+
+transformed data {
+  int n_occ_minus_1 = n_occasions - 1;
+  //  int n_occ_minus_1;
+  int<lower=0,upper=n_occasions> first[nind];
+  int<lower=0,upper=n_occasions> last[nind];
+
+  //  n_occ_minus_1 = n_occasions - 1;
+  for (i in 1:nind)
+    first[i] = first_capture(y[i]);
+  for (i in 1:nind)
+    last[i] = last_capture(y[i]);
+}
+
+parameters {
+  real<lower=0,upper=1> mean_phi;    // Mean survival
+  real<lower=0,upper=1> mean_p;      // Mean recapture
+}
+
+transformed parameters {
+  matrix<lower=0,upper=1>[nind, n_occ_minus_1] phi;
+  matrix<lower=0,upper=1>[nind, n_occ_minus_1] p;
+  matrix<lower=0,upper=1>[nind, n_occasions] chi;
+
+  // Constraints
+  for (i in 1:nind) {
+    for (t in 1:(first[i] - 1)) {
+      phi[i, t] = 0;
+      p[i, t] = 0;
+    }
+    for (t in first[i]:n_occ_minus_1) {
+      phi[i, t] = mean_phi;
+      p[i, t] = mean_p;
+    }
+  }
+
+  chi = prob_uncaptured(nind, n_occasions, p, phi);
+}
+
+model {
+  // Priors
+  // Uniform priors are implicitly defined.
+  //  mean_phi ~ uniform(0, 1);
+  //  mean_p ~ uniform(0, 1);
+
+  // Likelihood
+  for (i in 1:nind) {
+    if (first[i] > 0) {
+      for (t in (first[i] + 1):last[i]) {
+        1 ~ bernoulli(phi[i, t - 1]);
+        y[i, t] ~ bernoulli(p[i, t - 1]);
+      }
+      1 ~ bernoulli(chi[i, last[i]]);
+    }
+  }
+}
diff --git a/test/integration/good/compiler-optimizations/off-dce.stan b/test/integration/good/compiler-optimizations/off-dce.stan
new file mode 100644
index 0000000000..5200dbfd0b
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/off-dce.stan
@@ -0,0 +1,75 @@
+// Site-occupancy models with covariates
+
+data {
+  int<lower=1> R;                 // Number of sites
+  int<lower=1> T;                 // Number of temporal replications
+  int<lower=0,upper=1> y[R, T];   // Observation
+  vector[R] X;                    // Covariate
+}
+
+transformed data {
+  int<lower=0,upper=T> sum_y[R];  // Number of occupation for each site
+  int<lower=0,upper=R> occ_obs;   // Number of observed occupied sites
+
+  occ_obs = 0;
+  for (i in 1:R) {
+    sum_y[i] = sum(y[i]);
+    if (sum_y[i])
+      occ_obs = occ_obs + 1;
+  }
+}
+
+parameters {
+  real alpha_occ;
+  real beta_occ;
+  real alpha_p;
+  real beta_p;
+}
+
+transformed parameters {
+  vector[R] logit_psi;            // Logit occupancy probability
+  matrix[R, T] logit_p;           // Logit detection probability
+
+  logit_psi = alpha_occ + beta_occ * X;
+  logit_p = rep_matrix(alpha_p + beta_p * X, T);
+}
+
+model {
+  // Priors
+  // Improper flat priors are implicitly used on
+  // alpha_occ, beta_occ, alpha_p and beta_p.
+
+  // Likelihood
+  for (i in 1:R) {
+    if (sum_y[i]) {    // Occurred and observed
+      1 ~ bernoulli_logit(logit_psi[i]);
+      y[i] ~ bernoulli_logit(logit_p[i]);
+    } else {
+                            // Occurred and not observed
+      target += log_sum_exp(bernoulli_logit_lpmf(1 | logit_psi[i])
+                            + bernoulli_logit_lpmf(0 | logit_p[i]),
+                            // Not occurred
+                            bernoulli_logit_lpmf(0 | logit_psi[i]));
+    }
+  }
+}
+
+generated quantities {
+  int occ_fs;       // Number of occupied sites
+  real psi_con[R];  // prob occupied conditional on data
+  int z[R];         // occupancy indicator, 0/1
+  
+  for (i in 1:R) {
+    if (sum_y[i] == 0) {  // species not detected
+      real psi = inv_logit(logit_psi[i]);
+      vector[T] q = inv_logit(-logit_p[i])';  // q = 1 - p
+      real qT = prod(q[]);
+      psi_con[i] = (psi * qT) / (psi * qT + (1 - psi));
+      z[i] = bernoulli_rng(psi_con[i]);
+    } else {             // species detected at least once
+      psi_con[i] = 1;
+      z[i] = 1;
+    }
+  }
+  occ_fs = sum(z);
+}
diff --git a/test/integration/good/compiler-optimizations/off-small.stan b/test/integration/good/compiler-optimizations/off-small.stan
new file mode 100644
index 0000000000..3c012fdc5a
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/off-small.stan
@@ -0,0 +1,40 @@
+data {
+  int<lower=0> J; 
+  int<lower=0> N;
+  int<lower=1,upper=J> person[N];
+  vector[N] time;
+  vector[N] treatment;
+  vector[N] y;
+} 
+parameters {
+  real beta;
+  vector[J] eta1;
+  vector[J] eta2;
+  real mu_a1;
+  real mu_a2;
+  real<lower=0,upper=100> sigma_a1;
+  real<lower=0,upper=100> sigma_a2;
+  real<lower=0,upper=100> sigma_y;
+}
+transformed parameters {
+  vector[J] a1;
+  vector[J] a2;
+  vector[N] y_hat;
+
+  a1 = 10 * mu_a1 + sigma_a1 * eta1;
+  a2 = 0.1 * mu_a2 + sigma_a2 * eta2;
+
+  for (i in 1:N)
+    y_hat[i] = beta * time[i] * treatment[i] + a1[person[i]] 
+                + a2[person[i]] * time[i];
+} 
+model {
+  mu_a1 ~ normal(0, 1);
+  eta1 ~ normal (0, 1);
+  mu_a2 ~ normal(0, 1);
+  eta2 ~ normal (0, 1);
+
+  beta ~ normal (0, 1);
+
+  y ~ normal(y_hat, sigma_y);
+}
diff --git a/test/integration/good/compiler-optimizations/partial-eval.stan b/test/integration/good/compiler-optimizations/partial-eval.stan
new file mode 100644
index 0000000000..1114524265
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/partial-eval.stan
@@ -0,0 +1,28 @@
+data {
+  int<lower=0> N;
+  int<lower=0> n_pair;
+  int<lower=1,upper=n_pair> pair[N];
+  vector[N] pre_test;
+  vector<lower=0,upper=1>[N] treatment;
+  vector[N] y;
+}
+parameters {
+  vector[n_pair] a;
+  vector[2] beta;
+  real mu_a;
+  real<lower=0,upper=100> sigma_a;
+  real<lower=0,upper=100> sigma_y;
+}
+transformed parameters {
+  vector[N] y_hat;
+
+  for (i in 1:N)
+    y_hat[i] = a[pair[i]] + beta[1] * treatment[i] 
+                  + beta[2] * pre_test[i];
+}
+model {
+  mu_a ~ normal(0, 1);
+  a ~ normal(100 * mu_a, sigma_a);
+  beta ~ normal(0, 100);
+  y ~ normal(y_hat, sigma_y);
+}
diff --git a/test/integration/good/compiler-optimizations/stalled1-failure.stan b/test/integration/good/compiler-optimizations/stalled1-failure.stan
new file mode 100644
index 0000000000..813ed73f9b
--- /dev/null
+++ b/test/integration/good/compiler-optimizations/stalled1-failure.stan
@@ -0,0 +1,53 @@
+# Using Data Cloning to Calculate MLEs for the Seeds Model in vol1 
+# http://www.openbugs.net/Examples/DataCloning.html
+
+# The basic idea is that we raise the likelihood in the 
+# posterior to the power of K so that the posterior
+# estimates would concentrate on the MLE estimates. 
+# Reference: 
+#   Ecology Letters
+#   Subhash R. Lele Brian Dennis Frithjof Lutscher
+#   DOI: 10.1111/j.1461-0248.2007.01047.x
+#   http://onlinelibrary.wiley.com/doi/10.1111/j.1461-0248.2007.01047.x/abstract
+
+
+data {
+    int<lower=0> I;
+    int<lower=0> n[I];
+    int<lower=0> N[I];
+    vector[I] x1;
+    vector[I] x2;
+} 
+
+transformed data {
+    int K; 
+    vector[I] x1x2;
+    K <- 8; // {1, 2, 4, 8, 16, 32, 64, 128, 256}
+    x1x2 <- x1 .* x2;
+} 
+
+parameters {
+    real alpha0;
+    real alpha1;
+    real alpha2;
+    real alpha12;
+    real<lower=0> tau;
+    vector[K] b[I];
+} 
+
+transformed parameters {
+    real sigma; 
+    sigma <- 1 / sqrt(tau); 
+} 
+
+model {  
+   alpha0 ~ normal(0.0, 1.0E3);
+   alpha1 ~ normal(0.0, 1.0E3);
+   alpha2 ~ normal(0.0, 1.0E3);
+   alpha12 ~ normal(0.0, 1.0E3);
+   tau ~ gamma(1.0E-3, 1.0E-3);
+   for (i in 1:I) {
+      b[i] ~ normal(0.0, sigma);
+      n[i] ~ binomial_logit(N[i], alpha0 + alpha1 * x1[i] + alpha2 * x2[i] + alpha12 * x1x2[i] + b[i]);
+   }
+} 
diff --git a/test/unit/Dataflow_utils.ml b/test/unit/Dataflow_utils.ml
index 96976e0202..e124d18fd8 100644
--- a/test/unit/Dataflow_utils.ml
+++ b/test/unit/Dataflow_utils.ml
@@ -86,8 +86,8 @@ let%expect_test "Loop test" =
            ((filename string) (line_num 4) (col_num 10) (included_from ())))
           (end_loc
            ((filename string) (line_num 4) (col_num 23) (included_from ())))))))
-      (3)
-      ((1 ()) (2 (1)) (3 (2 5)) (4 (3)) (5 (4)))
+      (1)
+      ((1 (2)) (2 (3)) (3 (4)) (4 (5)) (5 (3)))
     |}]
 
 let%expect_test "Loop passthrough" =
@@ -131,7 +131,7 @@ let%expect_test "Loop passthrough" =
   let exits, _ = build_predecessor_graph statement_map in
   print_s [%sexp (exits : label Set.Poly.t)] ;
   [%expect {|
-      (7 11 17 21)
+      (1)
     |}]
 
 let example1_program =
@@ -290,10 +290,11 @@ let%expect_test "Predecessor graph example" =
       ((exits, preds) : label Set.Poly.t * (label, label Set.Poly.t) Map.Poly.t)] ;
   [%expect
     {|
-      ((7 9 13)
-       ((1 ()) (2 (1)) (3 (2)) (4 (3)) (5 (4)) (6 (5)) (7 (6)) (8 (5))
-        (9 (8 16 19 22)) (10 (9)) (11 (10)) (12 (11)) (13 (12)) (14 (13)) (15 (14))
-        (16 (15)) (17 (16)) (18 (17)) (19 (18)) (20 (17)) (21 (20)) (22 (19 21))))
+      ((1)
+       ((1 (2)) (2 (6 8)) (3 ()) (4 (3)) (5 (4)) (6 (7)) (7 (5)) (8 (9 13))
+        (9 (5 10 16 19)) (10 (22)) (11 (9)) (12 (13)) (13 (11)) (14 (11 12))
+        (15 (16)) (16 (14)) (17 (14 15)) (18 (19)) (19 (17)) (20 (21)) (21 (17))
+        (22 (18 20))))
     |}]
 
 let%expect_test "Controlflow graph example" =
@@ -405,7 +406,7 @@ let%expect_test "Predecessor graph example 3" =
       ((exits, preds) : label Set.Poly.t * (label, label Set.Poly.t) Map.Poly.t)] ;
   [%expect
     {|
-      ((6) ((1 ()) (2 (1)) (3 (2)) (4 (3 5)) (5 (4)) (6 (4))))
+      ((2) ((1 ()) (2 (3)) (3 (6)) (4 (1 5)) (5 (4)) (6 (4))))
     |}]
 
 let example4_program =
@@ -507,7 +508,7 @@ let%expect_test "Predecessor graph example 4" =
       ((exits, preds) : label Set.Poly.t * (label, label Set.Poly.t) Map.Poly.t)] ;
   [%expect
     {|
-      ((4) ((1 ()) (2 (1)) (3 (2)) (4 (3 6 7)) (5 (4)) (6 (5)) (7 (6))))
+      ((2) ((1 ()) (2 (3)) (3 (4)) (4 (1 5 6)) (5 (7)) (6 (4)) (7 (6))))
     |}]
 
 let example5_program =
@@ -614,5 +615,5 @@ let%expect_test "Predecessor graph example 5" =
       ((exits, preds) : label Set.Poly.t * (label, label Set.Poly.t) Map.Poly.t)] ;
   [%expect
     {|
-      ((8) ((1 ()) (2 (1)) (3 (2)) (4 (3 7)) (5 (4)) (6 (5)) (7 (6)) (8 (4 6))))
+      ((2) ((1 ()) (2 (3)) (3 (8)) (4 (1 5)) (5 (7)) (6 (4)) (7 (6)) (8 (4 6))))
     |}]
diff --git a/test/unit/Dependence_analysis.ml b/test/unit/Dependence_analysis.ml
index a13438120e..8787ceac52 100644
--- a/test/unit/Dependence_analysis.ml
+++ b/test/unit/Dependence_analysis.ml
@@ -74,8 +74,8 @@ let%expect_test "Reaching defns example" =
     [%sexp (deps : (label, label Set.Poly.t * label Set.Poly.t) Map.Poly.t)] ;
   [%expect
     {|
-      ((1 (() ())) (2 (() ())) (3 (() ())) (4 (() ())) (5 (() ())) (6 (() ()))
-       (7 (() ())) (8 (() ())) (9 ((9) (9))) (10 ((9) (9))) (11 ((9) (9)))
+      ((1 (() ())) (2 ((9) (9))) (3 (() ())) (4 (() ())) (5 (() ())) (6 (() ()))
+       (7 (() ())) (8 ((9) (9))) (9 ((9) (9))) (10 ((9) (9))) (11 ((9) (9)))
        (12 ((9) (9))) (13 ((9) (9))) (14 ((9) (9))) (15 ((9) (9))) (16 ((9) (9)))
        (17 ((9) (9))) (18 ((9) (9))) (19 ((9) (9))) (20 ((9) (9))) (21 ((9) (9)))
        (22 ((9) (9))))
@@ -95,10 +95,11 @@ let%expect_test "Reaching defns example" =
           Map.Poly.t )] ;
   [%expect
     {|
-      ((1 (() ())) (2 (() ())) (3 (() (((VVar i) 3))))
-       (4 ((((VVar i) 3)) (((VVar i) 4)))) (5 ((((VVar i) 4)) (((VVar i) 4))))
-       (6 ((((VVar i) 4)) (((VVar i) 4)))) (7 ((((VVar i) 4)) (((VVar i) 4))))
-       (8 ((((VVar i) 4)) (((VVar i) 4))))
+      ((1 (() ())) (2 ((((VVar i) 4) ((VVar j) 9)) (((VVar i) 4) ((VVar j) 9))))
+       (3 (() (((VVar i) 3)))) (4 ((((VVar i) 3)) (((VVar i) 4))))
+       (5 ((((VVar i) 4)) (((VVar i) 4)))) (6 ((((VVar i) 4)) (((VVar i) 4))))
+       (7 ((((VVar i) 4)) (((VVar i) 4))))
+       (8 ((((VVar i) 4) ((VVar j) 9)) (((VVar i) 4) ((VVar j) 9))))
        (9 ((((VVar i) 4) ((VVar j) 9)) (((VVar i) 4) ((VVar j) 9))))
        (10 ((((VVar i) 4) ((VVar j) 9)) (((VVar i) 4) ((VVar j) 9))))
        (11 ((((VVar i) 4) ((VVar j) 9)) (((VVar i) 4) ((VVar j) 9))))
diff --git a/test/unit/Optimize.ml b/test/unit/Optimize.ml
index b03d1e678c..5ea2ab280a 100644
--- a/test/unit/Optimize.ml
+++ b/test/unit/Optimize.ml
@@ -153,16 +153,21 @@ let%expect_test "inline functions" =
 
       log_prob {
         {
-          for(sym1__ in 1:1) {
+          data int inline_sym1__;
+          inline_sym1__ = 0;
+          for(inline_sym2__ in 1:1) {
             FnPrint__(3);
             FnPrint__(FnMakeRowVec__(FnMakeRowVec__(3, 2), FnMakeRowVec__(4, 6)));
           }
-          real sym4__;
-          for(sym3__ in 1:1) {
-            sym4__ = (53 ^ 2);
+          real inline_sym3__;
+          data int inline_sym4__;
+          inline_sym4__ = 0;
+          for(inline_sym5__ in 1:1) {
+            inline_sym4__ = 1;
+            inline_sym3__ = (53 ^ 2);
             break;
           }
-          FnReject__(sym4__);
+          FnReject__(inline_sym3__);
         }
       }
 
@@ -219,10 +224,15 @@ let%expect_test "inline functions 2" =
         }
         if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
         if(PNot__(emit_generated_quantities__)) return;
-        for(sym3__ in 1:1) {
-          for(sym1__ in 1:1) {
+        data int inline_sym7__;
+        inline_sym7__ = 0;
+        for(inline_sym8__ in 1:1) {
+          data int inline_sym5__;
+          inline_sym5__ = 0;
+          for(inline_sym6__ in 1:1) {
 
           }
+          if(inline_sym7__) break;
         }
       } |}]
 
@@ -292,7 +302,16 @@ let%expect_test "list collapsing" =
       (((pattern
          (Block
           (((pattern
-             (For (loopvar sym1__)
+             (Decl (decl_adtype DataOnly) (decl_id inline_sym1__)
+              (decl_type (Sized SInt))))
+            (meta <opaque>))
+           ((pattern
+             (Assignment (inline_sym1__ UInt ())
+              ((pattern (Lit Int 0))
+               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
+            (meta <opaque>))
+           ((pattern
+             (For (loopvar inline_sym2__)
               (lower
                ((pattern (Lit Int 1))
                 (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -339,11 +358,20 @@ let%expect_test "list collapsing" =
                 (meta <opaque>)))))
             (meta <opaque>))
            ((pattern
-             (Decl (decl_adtype AutoDiffable) (decl_id sym4__)
+             (Decl (decl_adtype AutoDiffable) (decl_id inline_sym3__)
               (decl_type (Unsized UReal))))
             (meta <opaque>))
            ((pattern
-             (For (loopvar sym3__)
+             (Decl (decl_adtype DataOnly) (decl_id inline_sym4__)
+              (decl_type (Sized SInt))))
+            (meta <opaque>))
+           ((pattern
+             (Assignment (inline_sym4__ UInt ())
+              ((pattern (Lit Int 0))
+               (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
+            (meta <opaque>))
+           ((pattern
+             (For (loopvar inline_sym5__)
               (lower
                ((pattern (Lit Int 1))
                 (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly)))))
@@ -354,7 +382,12 @@ let%expect_test "list collapsing" =
                ((pattern
                  (Block
                   (((pattern
-                     (Assignment (sym4__ UReal ())
+                     (Assignment (inline_sym4__ UInt ())
+                      ((pattern (Lit Int 1))
+                       (meta ((type_ UInt) (loc <opaque>) (adlevel DataOnly))))))
+                    (meta <opaque>))
+                   ((pattern
+                     (Assignment (inline_sym3__ UReal ())
                       ((pattern
                         (FunApp StanLib Pow__
                          (((pattern (Lit Int 53))
@@ -370,7 +403,7 @@ let%expect_test "list collapsing" =
             (meta <opaque>))
            ((pattern
              (NRFunApp CompilerInternal FnReject__
-              (((pattern (Var sym4__))
+              (((pattern (Var inline_sym3__))
                 (meta ((type_ UReal) (loc <opaque>) (adlevel AutoDiffable)))))))
             (meta <opaque>)))))
         (meta <opaque>))))
@@ -502,25 +535,34 @@ let%expect_test "inline function in for loop" =
 
       log_prob {
         {
-          int sym3__;
-          int sym6__;
-          for(sym2__ in 1:1) {
+          int inline_sym1__;
+          int inline_sym4__;
+          data int inline_sym2__;
+          inline_sym2__ = 0;
+          for(inline_sym3__ in 1:1) {
             FnPrint__("f");
-            sym3__ = 42;
+            inline_sym2__ = 1;
+            inline_sym1__ = 42;
             break;
           }
-          for(sym5__ in 1:1) {
+          data int inline_sym5__;
+          inline_sym5__ = 0;
+          for(inline_sym6__ in 1:1) {
             FnPrint__("g");
-            sym6__ = (3 + 24);
+            inline_sym5__ = 1;
+            inline_sym4__ = (3 + 24);
             break;
           }
-          for(i in sym3__:sym6__) {
+          for(i in inline_sym1__:inline_sym4__) {
             {
               FnPrint__("body");
             }
-            for(sym5__ in 1:1) {
+            data int inline_sym5__;
+            inline_sym5__ = 0;
+            for(inline_sym6__ in 1:1) {
               FnPrint__("g");
-              sym6__ = (3 + 24);
+              inline_sym5__ = 1;
+              inline_sym4__ = (3 + 24);
               break;
             }
           }
@@ -582,37 +624,54 @@ let%expect_test "inline function in for loop 2" =
 
       log_prob {
         {
-          int sym9__;
-          int sym12__;
-          for(sym8__ in 1:1) {
+          int inline_sym7__;
+          int inline_sym10__;
+          data int inline_sym8__;
+          inline_sym8__ = 0;
+          for(inline_sym9__ in 1:1) {
             FnPrint__("f");
-            sym9__ = 42;
+            inline_sym8__ = 1;
+            inline_sym7__ = 42;
             break;
           }
-          for(sym11__ in 1:1) {
+          data int inline_sym14__;
+          inline_sym14__ = 0;
+          for(inline_sym15__ in 1:1) {
             FnPrint__("g");
-            int sym13__;
-            for(sym5__ in 1:1) {
+            int inline_sym11__;
+            data int inline_sym12__;
+            inline_sym12__ = 0;
+            for(inline_sym13__ in 1:1) {
               FnPrint__("f");
-              sym13__ = 42;
+              inline_sym12__ = 1;
+              inline_sym11__ = 42;
               break;
             }
-            sym12__ = (sym13__ + 24);
+            if(inline_sym14__) break;
+            inline_sym14__ = 1;
+            inline_sym10__ = (inline_sym11__ + 24);
             break;
           }
-          for(i in sym9__:sym12__) {
+          for(i in inline_sym7__:inline_sym10__) {
             {
               FnPrint__("body");
             }
-            for(sym11__ in 1:1) {
+            data int inline_sym14__;
+            inline_sym14__ = 0;
+            for(inline_sym15__ in 1:1) {
               FnPrint__("g");
-              int sym13__;
-              for(sym5__ in 1:1) {
+              int inline_sym11__;
+              data int inline_sym12__;
+              inline_sym12__ = 0;
+              for(inline_sym13__ in 1:1) {
                 FnPrint__("f");
-                sym13__ = 42;
+                inline_sym12__ = 1;
+                inline_sym11__ = 42;
                 break;
               }
-              sym12__ = (sym13__ + 24);
+              if(inline_sym14__) break;
+              inline_sym14__ = 1;
+              inline_sym10__ = (inline_sym11__ + 24);
               break;
             }
           }
@@ -672,17 +731,23 @@ let%expect_test "inline function in while loop" =
 
       log_prob {
         {
-          int sym3__;
-          for(sym2__ in 1:1) {
+          int inline_sym1__;
+          data int inline_sym2__;
+          inline_sym2__ = 0;
+          for(inline_sym3__ in 1:1) {
             FnPrint__("g");
-            sym3__ = (3 + 24);
+            inline_sym2__ = 1;
+            inline_sym1__ = (3 + 24);
             break;
           }
-          while(sym3__) {
+          while(inline_sym1__) {
             FnPrint__("body");
-            for(sym2__ in 1:1) {
+            data int inline_sym2__;
+            inline_sym2__ = 0;
+            for(inline_sym3__ in 1:1) {
               FnPrint__("g");
-              sym3__ = (3 + 24);
+              inline_sym2__ = 1;
+              inline_sym1__ = (3 + 24);
               break;
             }
           }
@@ -742,13 +807,16 @@ let%expect_test "inline function in if then else" =
 
       log_prob {
         {
-          int sym3__;
-          for(sym2__ in 1:1) {
+          int inline_sym1__;
+          data int inline_sym2__;
+          inline_sym2__ = 0;
+          for(inline_sym3__ in 1:1) {
             FnPrint__("g");
-            sym3__ = (3 + 24);
+            inline_sym2__ = 1;
+            inline_sym1__ = (3 + 24);
             break;
           }
-          if(sym3__) FnPrint__("body");
+          if(inline_sym1__) FnPrint__("body");
         }
       }
 
@@ -817,28 +885,37 @@ let%expect_test "inline function in ternary if " =
 
       log_prob {
         {
-          int sym3__;
-          int sym6__;
-          int sym9__;
-          for(sym2__ in 1:1) {
+          int inline_sym1__;
+          int inline_sym4__;
+          int inline_sym7__;
+          data int inline_sym2__;
+          inline_sym2__ = 0;
+          for(inline_sym3__ in 1:1) {
             FnPrint__("f");
-            sym3__ = 42;
+            inline_sym2__ = 1;
+            inline_sym1__ = 42;
             break;
           }
-          if(sym3__) {
-            for(sym5__ in 1:1) {
+          if(inline_sym1__) {
+            data int inline_sym5__;
+            inline_sym5__ = 0;
+            for(inline_sym6__ in 1:1) {
               FnPrint__("g");
-              sym6__ = (3 + 24);
+              inline_sym5__ = 1;
+              inline_sym4__ = (3 + 24);
               break;
             }
           } else {
-            for(sym8__ in 1:1) {
+            data int inline_sym8__;
+            inline_sym8__ = 0;
+            for(inline_sym9__ in 1:1) {
               FnPrint__("h");
-              sym9__ = (4 + 4);
+              inline_sym8__ = 1;
+              inline_sym7__ = (4 + 4);
               break;
             }
           }
-          FnPrint__(sym3__ ?sym6__: sym9__);
+          FnPrint__(inline_sym1__ ?inline_sym4__: inline_sym7__);
         }
       }
 
@@ -891,17 +968,21 @@ let%expect_test "inline function multiple returns " =
 
       log_prob {
         {
-          int sym3__;
-          for(sym2__ in 1:1) {
+          int inline_sym1__;
+          data int inline_sym2__;
+          inline_sym2__ = 0;
+          for(inline_sym3__ in 1:1) {
             if(2) {
               FnPrint__("f");
-              sym3__ = 42;
+              inline_sym2__ = 1;
+              inline_sym1__ = 42;
               break;
             }
-            sym3__ = 6;
+            inline_sym2__ = 1;
+            inline_sym1__ = 6;
             break;
           }
-          FnPrint__(sym3__);
+          FnPrint__(inline_sym1__);
         }
       }
 
@@ -950,19 +1031,25 @@ let%expect_test "inline function indices " =
       log_prob {
         {
           array[array[int, 2], 2] a;
-          int sym6__;
-          int sym3__;
-          for(sym5__ in 1:1) {
+          int inline_sym4__;
+          int inline_sym1__;
+          data int inline_sym5__;
+          inline_sym5__ = 0;
+          for(inline_sym6__ in 1:1) {
             FnPrint__(2);
-            sym6__ = 42;
+            inline_sym5__ = 1;
+            inline_sym4__ = 42;
             break;
           }
-          for(sym2__ in 1:1) {
+          data int inline_sym2__;
+          inline_sym2__ = 0;
+          for(inline_sym3__ in 1:1) {
             FnPrint__(1);
-            sym3__ = 42;
+            inline_sym2__ = 1;
+            inline_sym1__ = 42;
             break;
           }
-          FnPrint__(a[sym3__, sym6__]);
+          FnPrint__(a[inline_sym1__, inline_sym4__]);
         }
       }
 
@@ -1010,21 +1097,27 @@ let%expect_test "inline function and " =
 
       log_prob {
         {
-          int sym3__;
-          int sym6__;
-          for(sym2__ in 1:1) {
+          int inline_sym1__;
+          int inline_sym4__;
+          data int inline_sym2__;
+          inline_sym2__ = 0;
+          for(inline_sym3__ in 1:1) {
             FnPrint__(1);
-            sym3__ = 42;
+            inline_sym2__ = 1;
+            inline_sym1__ = 42;
             break;
           }
-          if(sym3__) {
-            for(sym5__ in 1:1) {
+          if(inline_sym1__) {
+            data int inline_sym5__;
+            inline_sym5__ = 0;
+            for(inline_sym6__ in 1:1) {
               FnPrint__(2);
-              sym6__ = 42;
+              inline_sym5__ = 1;
+              inline_sym4__ = 42;
               break;
             }
           }
-          FnPrint__(sym3__ && sym6__);
+          FnPrint__(inline_sym1__ && inline_sym4__);
         }
       }
 
@@ -1071,21 +1164,27 @@ let%expect_test "inline function or " =
 
       log_prob {
         {
-          int sym3__;
-          int sym6__;
-          for(sym2__ in 1:1) {
+          int inline_sym1__;
+          int inline_sym4__;
+          data int inline_sym2__;
+          inline_sym2__ = 0;
+          for(inline_sym3__ in 1:1) {
             FnPrint__(1);
-            sym3__ = 42;
+            inline_sym2__ = 1;
+            inline_sym1__ = 42;
             break;
           }
-          if(sym3__) ; else {
-            for(sym5__ in 1:1) {
+          if(inline_sym1__) ; else {
+            data int inline_sym5__;
+            inline_sym5__ = 0;
+            for(inline_sym6__ in 1:1) {
               FnPrint__(2);
-              sym6__ = 42;
+              inline_sym5__ = 1;
+              inline_sym4__ = 42;
               break;
             }
           }
-          FnPrint__(sym3__ || sym6__);
+          FnPrint__(inline_sym1__ || inline_sym4__);
         }
       }
 
@@ -1669,14 +1768,12 @@ let%expect_test "copy propagation" =
   let ast =
     Parse.parse_string Parser.Incremental.program
       {|
-      transformed data {
+      model {
         int i;
         int j;
         j = i;
         int k;
         k = 2 * j;
-      }
-      model {
         for (x in 1:i) {
           print(i + j + k);
         }
@@ -1689,16 +1786,13 @@ let%expect_test "copy propagation" =
   Fmt.strf "@[<v>%a@]" Program.Typed.pp mir |> print_endline ;
   [%expect
     {|
-      prepare_data {
-        data int i;
-        data int j;
-        j = i;
-        data int k;
-        k = (2 * i);
-      }
-
       log_prob {
         {
+          int i;
+          int j;
+          j = i;
+          int k;
+          k = (2 * i);
           for(x in 1:i) {
             FnPrint__(((i + i) + k));
           }
@@ -1737,6 +1831,7 @@ let%expect_test "dead code elimination" =
     {|
       prepare_data {
         data array[int, 2] i;
+        i[1] = 2;
         i = FnMakeArray__(3, 2);
         data array[int, 2] j;
         j = FnMakeArray__(3, 2);
@@ -2390,26 +2485,20 @@ let%expect_test "lazy code motion" =
   [%expect
     {|
     log_prob {
-      data real[] sym3__;
+      data real[] lcm_sym3__;
       {
-        sym3__ = FnMakeArray__(3.0);
-        FnPrint__(sym3__);
-        FnPrint__(sym3__);
-        FnPrint__(sym3__);
+        lcm_sym3__ = FnMakeArray__(3.0);
+        FnPrint__(lcm_sym3__);
+        FnPrint__(lcm_sym3__);
+        FnPrint__(lcm_sym3__);
       }
     }
 
     generate_quantities {
-      data int sym2__;
-      data int sym1__;
-      if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-        return;
-        ;
-      } else ;
-      if(PNot__(emit_generated_quantities__)) {
-        return;
-        ;
-      } else ;
+      data int lcm_sym2__;
+      data int lcm_sym1__;
+      if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+      if(PNot__(emit_generated_quantities__)) return;
     } |}]
 
 let%expect_test "lazy code motion, 2" =
@@ -2431,29 +2520,19 @@ let%expect_test "lazy code motion, 2" =
   [%expect
     {|
       log_prob {
-        data int sym4__;
-        data int sym3__;
+        data int lcm_sym3__;
         {
           for(i in 1:2) {
-            {
-              FnPrint__((3 + 4));
-            }
-            ;
+            FnPrint__((3 + 4));
           }
         }
       }
 
       generate_quantities {
-        data int sym2__;
-        data int sym1__;
-        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
-        if(PNot__(emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
+        data int lcm_sym2__;
+        data int lcm_sym1__;
+        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+        if(PNot__(emit_generated_quantities__)) return;
       } |}]
 
 let%expect_test "lazy code motion, 3" =
@@ -2476,27 +2555,21 @@ let%expect_test "lazy code motion, 3" =
   [%expect
     {|
       log_prob {
-        data int sym4__;
-        data int sym3__;
+        data int lcm_sym4__;
+        data int lcm_sym3__;
         {
           FnPrint__(3);
-          sym3__ = (3 + 5);
-          FnPrint__(sym3__);
-          FnPrint__((sym3__ + 7));
+          lcm_sym3__ = (3 + 5);
+          FnPrint__(lcm_sym3__);
+          FnPrint__((lcm_sym3__ + 7));
         }
       }
 
       generate_quantities {
-        data int sym2__;
-        data int sym1__;
-        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
-        if(PNot__(emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
+        data int lcm_sym2__;
+        data int lcm_sym1__;
+        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+        if(PNot__(emit_generated_quantities__)) return;
       } |}]
 
 let%expect_test "lazy code motion, 4" =
@@ -2532,7 +2605,7 @@ let%expect_test "lazy code motion, 4" =
   [%expect
     {|
       log_prob {
-        data int sym3__;
+        data int lcm_sym3__;
         {
           int b;
           int c;
@@ -2545,31 +2618,25 @@ let%expect_test "lazy code motion, 4" =
               ;
               ;
             }
-            sym3__ = (b + c);
+            lcm_sym3__ = (b + c);
             ;
           } else {
             {
-              sym3__ = (b + c);
-              x = sym3__;
+              lcm_sym3__ = (b + c);
+              x = lcm_sym3__;
               ;
             }
             ;
           }
-          y = sym3__;
+          y = lcm_sym3__;
         }
       }
 
       generate_quantities {
-        data int sym2__;
-        data int sym1__;
-        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
-        if(PNot__(emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
+        data int lcm_sym2__;
+        data int lcm_sym1__;
+        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+        if(PNot__(emit_generated_quantities__)) return;
       } |}]
 
 let%expect_test "lazy code motion, 5" =
@@ -2603,7 +2670,7 @@ let%expect_test "lazy code motion, 5" =
   [%expect
     {|
       log_prob {
-        data int sym3__;
+        data int lcm_sym3__;
         {
           int b;
           int c;
@@ -2616,35 +2683,29 @@ let%expect_test "lazy code motion, 5" =
               ;
               ;
             }
-            sym3__ = (b + c);
+            lcm_sym3__ = (b + c);
             ;
           } else {
             {
               if(2) {
-                sym3__ = (b + c);
-                x = sym3__;
+                lcm_sym3__ = (b + c);
+                x = lcm_sym3__;
                 ;
-              } else sym3__ = (b + c);
+              } else lcm_sym3__ = (b + c);
                      ;
               ;
             }
             ;
           }
-          y = sym3__;
+          y = lcm_sym3__;
         }
       }
 
       generate_quantities {
-        data int sym2__;
-        data int sym1__;
-        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
-        if(PNot__(emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
+        data int lcm_sym2__;
+        data int lcm_sym1__;
+        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+        if(PNot__(emit_generated_quantities__)) return;
       } |}]
 
 let%expect_test "lazy code motion, 6" =
@@ -2669,30 +2730,21 @@ let%expect_test "lazy code motion, 6" =
   [%expect
     {|
       log_prob {
-        data int sym4__;
-        data int sym3__;
+        data int lcm_sym4__;
+        data int lcm_sym3__;
         {
           int x;
           int y;
-          if(2) {
-            x = (1 + 2);
-            ;
-          } else ;
+          if(2) x = (1 + 2);
           y = (4 + 3);
         }
       }
 
       generate_quantities {
-        data int sym2__;
-        data int sym1__;
-        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
-        if(PNot__(emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
+        data int lcm_sym2__;
+        data int lcm_sym1__;
+        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+        if(PNot__(emit_generated_quantities__)) return;
       } |}]
 
 let%expect_test "lazy code motion, 7" =
@@ -2735,8 +2787,7 @@ let%expect_test "lazy code motion, 7" =
   [%expect
     {|
       log_prob {
-        data int sym4__;
-        data int sym3__;
+        data int lcm_sym3__;
         {
           int a;
           int b;
@@ -2745,62 +2796,32 @@ let%expect_test "lazy code motion, 7" =
           int y;
           int z;
           if(1) {
-            {
-              a = c;
-              x = (a + b);
-            }
-            ;
-          } else {
-            ;
-            ;
-          }
+            a = c;
+            x = (a + b);
+          } else ;
           if(2) {
-            {
-              if(3) {
-                {
-                  sym4__ = (a + b);
-                  ;
-                  while(4) {
-                    y = sym4__;
-                    ;
-                  }
-                  ;
-                }
-                ;
-              } else {
-                {
-                  ;
-                  while(5) {
-                    ;
-                    ;
-                  }
-                  sym4__ = (a + b);
-                  y = sym4__;
-                }
-                ;
-              }
-              z = sym4__;
+            if(3) {
+              lcm_sym3__ = (a + b);
+              ;
+              while(4) y = lcm_sym3__;
+              ;
+            } else {
+              ;
+              while(5) ;
+              lcm_sym3__ = (a + b);
+              y = lcm_sym3__;
             }
-            ;
-          } else {
-            ;
-            ;
-          }
+            z = lcm_sym3__;
+          } else ;
           ;
         }
       }
 
       generate_quantities {
-        data int sym2__;
-        data int sym1__;
-        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
-        if(PNot__(emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
+        data int lcm_sym2__;
+        data int lcm_sym1__;
+        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+        if(PNot__(emit_generated_quantities__)) return;
       } |}]
 
 let%expect_test "lazy code motion, 8, _lp functions not optimized" =
@@ -2844,27 +2865,21 @@ let%expect_test "lazy code motion, 8, _lp functions not optimized" =
 
 
       log_prob {
-        data int sym3__;
+        data int lcm_sym3__;
         {
           FnPrint__(foo(foo_lp(1)));
           FnPrint__(foo(foo_lp(1)));
-          sym3__ = foo(foo(1));
-          FnPrint__(sym3__);
-          FnPrint__(sym3__);
+          lcm_sym3__ = foo(foo(1));
+          FnPrint__(lcm_sym3__);
+          FnPrint__(lcm_sym3__);
         }
       }
 
       generate_quantities {
-        data int sym2__;
-        data int sym1__;
-        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
-        if(PNot__(emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
+        data int lcm_sym2__;
+        data int lcm_sym1__;
+        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+        if(PNot__(emit_generated_quantities__)) return;
       } |}]
 
 let%expect_test "lazy code motion, 9" =
@@ -2886,27 +2901,18 @@ let%expect_test "lazy code motion, 9" =
   [%expect
     {|
       log_prob {
-        data int sym3__;
+        data int lcm_sym3__;
         {
           int x;
-          while((x * 2)) {
-            FnPrint__("hello");
-            ;
-          }
+          while((x * 2)) FnPrint__("hello");
         }
       }
 
       generate_quantities {
-        data int sym2__;
-        data int sym1__;
-        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
-        if(PNot__(emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
+        data int lcm_sym2__;
+        data int lcm_sym1__;
+        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+        if(PNot__(emit_generated_quantities__)) return;
       } |}]
 
 let%expect_test "lazy code motion, 10" =
@@ -2931,7 +2937,7 @@ let%expect_test "lazy code motion, 10" =
   [%expect
     {|
       log_prob {
-        data int sym3__;
+        data int lcm_sym3__;
         {
           int x;
           x = 3;
@@ -2942,16 +2948,10 @@ let%expect_test "lazy code motion, 10" =
       }
 
       generate_quantities {
-        data int sym2__;
-        data int sym1__;
-        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
-        if(PNot__(emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
+        data int lcm_sym2__;
+        data int lcm_sym1__;
+        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+        if(PNot__(emit_generated_quantities__)) return;
       } |}]
 
 let%expect_test "lazy code motion, 11" =
@@ -2979,7 +2979,7 @@ let%expect_test "lazy code motion, 11" =
   [%expect
     {|
       log_prob {
-        data int sym3__;
+        data int lcm_sym3__;
         {
           {
             int x;
@@ -2993,16 +2993,10 @@ let%expect_test "lazy code motion, 11" =
       }
 
       generate_quantities {
-        data int sym2__;
-        data int sym1__;
-        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
-        if(PNot__(emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
+        data int lcm_sym2__;
+        data int lcm_sym1__;
+        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+        if(PNot__(emit_generated_quantities__)) return;
       } |}]
 
 let%expect_test "lazy code motion, 12" =
@@ -3027,31 +3021,21 @@ let%expect_test "lazy code motion, 12" =
   [%expect
     {|
       log_prob {
-        data int sym4__;
-        data int sym3__;
+        data int lcm_sym3__;
         {
           int x;
           for(i in 1:6) {
-            {
-              FnPrint__((x + 42));
-              x = 3;
-            }
-            ;
+            FnPrint__((x + 42));
+            x = 3;
           }
         }
       }
 
       generate_quantities {
-        data int sym2__;
-        data int sym1__;
-        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
-        if(PNot__(emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
+        data int lcm_sym2__;
+        data int lcm_sym1__;
+        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+        if(PNot__(emit_generated_quantities__)) return;
       } |}]
 
 let%expect_test "lazy code motion, 13" =
@@ -3084,62 +3068,44 @@ let%expect_test "lazy code motion, 13" =
   [%expect
     {|
       log_prob {
-        data int sym10__;
-        data int sym9__;
-        data int sym8__;
-        data int sym7__;
-        data int sym6__;
-        real sym5__;
-        real sym4__;
-        data int sym3__;
+        data int lcm_sym7__;
+        data int lcm_sym6__;
+        data int lcm_sym5__;
+        data int lcm_sym4__;
+        data int lcm_sym3__;
         {
           real temp;
           if((2 > 3)) {
-            sym9__ = (2 * 2);
-            temp = sym9__;
+            lcm_sym6__ = (2 * 2);
+            temp = lcm_sym6__;
             ;
           } else {
             FnPrint__("hello");
-            sym9__ = (2 * 2);
+            lcm_sym6__ = (2 * 2);
             ;
           }
-          temp = sym9__;
+          temp = lcm_sym6__;
           real temp2;
-          if((2 <= 3)) {
-            {
-              {
-                sym10__ = (2 * 3);
-                temp2 = sym10__;
-                sym4__ = temp;
-                target += sym4__;
-                sym8__ = (2 + 1);
-                target += temp2;
-              }
-              for(i in sym8__:3) {
-                {
-                  temp2 = sym10__;
-                  target += sym4__;
-                  target += temp2;
-                }
-                ;
-              }
+          if((3 >= 2)) {
+            lcm_sym7__ = (2 * 3);
+            temp2 = lcm_sym7__;
+            target += temp;
+            lcm_sym5__ = (2 + 1);
+            target += temp2;
+            for(i in lcm_sym5__:3) {
+              temp2 = lcm_sym7__;
+              target += temp;
+              target += temp2;
             }
-            ;
-          } else ;
+          }
         }
       }
 
       generate_quantities {
-        data int sym2__;
-        data int sym1__;
-        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
-        if(PNot__(emit_generated_quantities__)) {
-          return;
-          ;
-        } else ;
+        data int lcm_sym2__;
+        data int lcm_sym1__;
+        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+        if(PNot__(emit_generated_quantities__)) return;
       } |}]
 
 let%expect_test "cool example: expression propagation + partial evaluation + \
@@ -3171,41 +3137,30 @@ let%expect_test "cool example: expression propagation + partial evaluation + \
   [%expect
     {|
       log_prob {
-        real sym7__;
-        real sym6__;
-        data int sym5__;
-        data int sym4__;
-        data int sym3__;
+        real lcm_sym6__;
+        real lcm_sym5__;
+        data int lcm_sym4__;
+        data int lcm_sym3__;
         {
           real x;
           int y;
           real theta;
-          if((1 <= 100000)) {
-            {
-              {
-                sym5__ = (1 + 1);
-                sym6__ = bernoulli_logit_lpmf(y, x);
-                target += sym6__;
-              }
-              for(i in sym5__:100000) {
-                {
-                  target += sym6__;
-                }
-              }
+          if((100000 >= 1)) {
+            lcm_sym4__ = (1 + 1);
+            lcm_sym5__ = bernoulli_logit_lpmf(y, x);
+            target += lcm_sym5__;
+            for(i in lcm_sym4__:100000) {
+              target += lcm_sym5__;
             }
-          } else ;
+          }
         }
       }
 
       generate_quantities {
-        data int sym2__;
-        data int sym1__;
-        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) {
-          return;
-        } else ;
-        if(PNot__(emit_generated_quantities__)) {
-          return;
-        } else ;
+        data int lcm_sym2__;
+        data int lcm_sym1__;
+        if(PNot__(emit_transformed_parameters__ || emit_generated_quantities__)) return;
+        if(PNot__(emit_generated_quantities__)) return;
       } |}]
 
 let%expect_test "block fixing" =
@@ -3299,10 +3254,8 @@ let%expect_test "one-step loop unrolling" =
     {|
       prepare_data {
         data int x;
-        if((x <= 6)) {
-          {
-            FnPrint__("hello");
-          }
+        if((6 >= x)) {
+          FnPrint__("hello");
           for(i in (x + 1):6) {
             FnPrint__("hello");
           }
@@ -3311,22 +3264,16 @@ let%expect_test "one-step loop unrolling" =
           FnPrint__("goodbye");
           while((1 < 2)) FnPrint__("goodbye");
         }
-        if((1 <= 1)) {
-          {
-            if((2 <= 2)) {
-              {
-                FnPrint__("nested");
-              }
-              for(j in (2 + 1):2) {
-                FnPrint__("nested");
-              }
+        if((1 >= 1)) {
+          if((2 >= 2)) {
+            FnPrint__("nested");
+            for(j in (2 + 1):2) {
+              FnPrint__("nested");
             }
           }
           for(i in (1 + 1):1) {
-            if((2 <= 2)) {
-              {
-                FnPrint__("nested");
-              }
+            if((2 >= 2)) {
+              FnPrint__("nested");
               for(j in (2 + 1):2) {
                 FnPrint__("nested");
               }
@@ -3602,8 +3549,8 @@ let%expect_test "adlevel_optimization 2" =
         w_trans = 1;
         {
           data int x;
-          data array[real, 2] y;
-          data real z;
+          array[real, 2] y;
+          real z;
           data real z_data;
           if((1 > 2)) y[1] = (y[1] + x); else y[2] = (y[2] + w);
           if((2 > 1)) z = y[1];