diff --git a/stan/math/fwd/fun/determinant.hpp b/stan/math/fwd/fun/determinant.hpp
index 8f6b016a8b8..e3fee48d829 100644
--- a/stan/math/fwd/fun/determinant.hpp
+++ b/stan/math/fwd/fun/determinant.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/fwd/core.hpp>
 
 namespace stan {
@@ -12,9 +13,10 @@ namespace math {
 template <typename EigMat, require_eigen_vt<is_fvar, EigMat>* = nullptr>
 inline value_type_t<EigMat> determinant(const EigMat& m) {
   check_square("determinant", "m", m);
+  const auto& m_ref = to_ref(m);
 
-  const typename value_type_t<EigMat>::Scalar vals = m.val().determinant();
-  return {vals, vals * (m.val().inverse() * m.d()).trace()};
+  const typename value_type_t<EigMat>::Scalar vals = m_ref.val().determinant();
+  return {vals, vals * (m_ref.val().inverse() * m_ref.d()).trace()};
 }
 
 }  // namespace math
diff --git a/stan/math/fwd/fun/log_sum_exp.hpp b/stan/math/fwd/fun/log_sum_exp.hpp
index a99eb2dcf35..de64e918ac6 100644
--- a/stan/math/fwd/fun/log_sum_exp.hpp
+++ b/stan/math/fwd/fun/log_sum_exp.hpp
@@ -7,6 +7,7 @@
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/log_sum_exp.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <cmath>
 #include <vector>
 
@@ -52,15 +53,17 @@ inline fvar<T> log_sum_exp(const fvar<T>& x1, double x2) {
  */
 template <typename T, require_container_st<is_fvar, T>* = nullptr>
 inline auto log_sum_exp(const T& x) {
-  return apply_vector_unary<T>::reduce(x, [&](const auto& v) {
-    using T_fvar_inner = typename value_type_t<decltype(v)>::Scalar;
-    using mat_type = Eigen::Matrix<T_fvar_inner, -1, -1>;
-    mat_type vals = v.val();
-    mat_type exp_vals = vals.array().exp();
+  return apply_vector_unary<ref_type_t<T>>::reduce(
+      to_ref(x), [&](const auto& v) {
+        using T_fvar_inner = typename value_type_t<decltype(v)>::Scalar;
+        using mat_type = Eigen::Matrix<T_fvar_inner, -1, -1>;
+        mat_type vals = v.val();
+        mat_type exp_vals = vals.array().exp();
 
-    return fvar<T_fvar_inner>(
-        log_sum_exp(vals), v.d().cwiseProduct(exp_vals).sum() / exp_vals.sum());
-  });
+        return fvar<T_fvar_inner>(
+            log_sum_exp(vals),
+            v.d().cwiseProduct(exp_vals).sum() / exp_vals.sum());
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/fwd/fun/quad_form.hpp b/stan/math/fwd/fun/quad_form.hpp
index 29285b49763..57463397977 100644
--- a/stan/math/fwd/fun/quad_form.hpp
+++ b/stan/math/fwd/fun/quad_form.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/multiply.hpp>
 #include <stan/math/prim/fun/dot_product.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 
 namespace stan {
 namespace math {
@@ -31,7 +32,8 @@ inline promote_scalar_t<return_type_t<EigMat1, EigMat2>, EigMat2> quad_form(
     const EigMat1& A, const EigMat2& B) {
   check_square("quad_form", "A", A);
   check_multiplicable("quad_form", "A", A, "B", B);
-  return multiply(B.transpose(), multiply(A, B));
+  const auto& B_ref = to_ref(B);
+  return multiply(B_ref.transpose(), multiply(A, B_ref));
 }
 
 /**
@@ -53,7 +55,8 @@ inline return_type_t<EigMat, ColVec> quad_form(const EigMat& A,
                                                const ColVec& B) {
   check_square("quad_form", "A", A);
   check_multiplicable("quad_form", "A", A, "B", B);
-  return dot_product(B, multiply(A, B));
+  const auto& B_ref = to_ref(B);
+  return dot_product(B_ref, multiply(A, B_ref));
 }
 
 }  // namespace math
diff --git a/stan/math/fwd/fun/quad_form_sym.hpp b/stan/math/fwd/fun/quad_form_sym.hpp
index f0d36380cc8..28870641219 100644
--- a/stan/math/fwd/fun/quad_form_sym.hpp
+++ b/stan/math/fwd/fun/quad_form_sym.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/multiply.hpp>
 #include <stan/math/prim/fun/dot_product.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 
 namespace stan {
 namespace math {
@@ -31,7 +32,9 @@ inline promote_scalar_t<return_type_t<EigMat1, EigMat2>, EigMat2> quad_form_sym(
   using T_ret = return_type_t<EigMat1, EigMat2>;
   check_multiplicable("quad_form_sym", "A", A, "B", B);
   check_symmetric("quad_form_sym", "A", A);
-  promote_scalar_t<T_ret, EigMat2> ret(multiply(B.transpose(), multiply(A, B)));
+  const auto& B_ref = to_ref(B);
+  promote_scalar_t<T_ret, EigMat2> ret(
+      multiply(B_ref.transpose(), multiply(A, B_ref)));
   return T_ret(0.5) * (ret + ret.transpose());
 }
 
@@ -54,7 +57,8 @@ inline return_type_t<EigMat, ColVec> quad_form_sym(const EigMat& A,
                                                    const ColVec& B) {
   check_multiplicable("quad_form_sym", "A", A, "B", B);
   check_symmetric("quad_form_sym", "A", A);
-  return dot_product(B, multiply(A, B));
+  const auto& B_ref = to_ref(B);
+  return dot_product(B_ref, multiply(A, B_ref));
 }
 
 }  // namespace math
diff --git a/stan/math/fwd/fun/softmax.hpp b/stan/math/fwd/fun/softmax.hpp
index e625bf42038..b23af3abaae 100644
--- a/stan/math/fwd/fun/softmax.hpp
+++ b/stan/math/fwd/fun/softmax.hpp
@@ -2,8 +2,11 @@
 #define STAN_MATH_FWD_FUN_SOFTMAX_HPP
 
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/fun/value_of.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/softmax.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
+#include <stan/math/prim/fun/value_of.hpp>
 
 namespace stan {
 namespace math {
@@ -14,13 +17,9 @@ inline auto softmax(const ColVec& alpha) {
   using Eigen::Dynamic;
   using Eigen::Matrix;
   using T = typename value_type_t<ColVec>::Scalar;
+  const auto& alpha_ref = to_ref(alpha);
 
-  Matrix<T, Dynamic, 1> alpha_t(alpha.size());
-  for (int k = 0; k < alpha.size(); ++k) {
-    alpha_t.coeffRef(k) = alpha.coeff(k).val_;
-  }
-
-  Matrix<T, Dynamic, 1> softmax_alpha_t = softmax(alpha_t);
+  Matrix<T, Dynamic, 1> softmax_alpha_t = softmax(value_of(alpha_ref));
 
   Matrix<fvar<T>, Dynamic, 1> softmax_alpha(alpha.size());
   for (int k = 0; k < alpha.size(); ++k) {
@@ -30,12 +29,12 @@ inline auto softmax(const ColVec& alpha) {
 
   for (int m = 0; m < alpha.size(); ++m) {
     T negative_alpha_m_d_times_softmax_alpha_t_m
-        = -alpha.coeff(m).d_ * softmax_alpha_t.coeff(m);
+        = -alpha_ref.coeff(m).d_ * softmax_alpha_t.coeff(m);
     for (int k = 0; k < alpha.size(); ++k) {
       if (m == k) {
         softmax_alpha.coeffRef(k).d_
             += softmax_alpha_t.coeff(k)
-               * (alpha.coeff(m).d_
+               * (alpha_ref.coeff(m).d_
                   + negative_alpha_m_d_times_softmax_alpha_t_m);
       } else {
         softmax_alpha.coeffRef(k).d_
diff --git a/stan/math/fwd/fun/tcrossprod.hpp b/stan/math/fwd/fun/tcrossprod.hpp
index 6c338e5a3c7..7ebf4ed05ff 100644
--- a/stan/math/fwd/fun/tcrossprod.hpp
+++ b/stan/math/fwd/fun/tcrossprod.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/transpose.hpp>
 #include <stan/math/fwd/fun/multiply.hpp>
 
@@ -16,7 +17,8 @@ tcrossprod(const EigMat& m) {
   if (m.rows() == 0) {
     return {};
   }
-  return multiply(m, m.transpose());
+  const auto& m_ref = to_ref(m);
+  return multiply(m_ref, m_ref.transpose());
 }
 
 }  // namespace math
diff --git a/stan/math/fwd/fun/trace_quad_form.hpp b/stan/math/fwd/fun/trace_quad_form.hpp
index 26be884dedc..5720ddc6734 100644
--- a/stan/math/fwd/fun/trace_quad_form.hpp
+++ b/stan/math/fwd/fun/trace_quad_form.hpp
@@ -6,6 +6,7 @@
 #include <stan/math/prim/fun/multiply.hpp>
 #include <stan/math/prim/fun/transpose.hpp>
 #include <stan/math/prim/fun/trace.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/fwd/core.hpp>
 
 namespace stan {
@@ -18,7 +19,8 @@ inline return_type_t<EigMat1, EigMat2> trace_quad_form(const EigMat1& A,
                                                        const EigMat2& B) {
   check_square("trace_quad_form", "A", A);
   check_multiplicable("trace_quad_form", "A", A, "B", B);
-  return B.cwiseProduct(multiply(A, B)).sum();
+  const auto& B_ref = to_ref(B);
+  return B_ref.cwiseProduct(multiply(A, B_ref)).sum();
 }
 
 }  // namespace math
diff --git a/stan/math/prim/err/check_symmetric.hpp b/stan/math/prim/err/check_symmetric.hpp
index d1fc01cd96b..e5ab17cee77 100644
--- a/stan/math/prim/err/check_symmetric.hpp
+++ b/stan/math/prim/err/check_symmetric.hpp
@@ -19,7 +19,7 @@ namespace math {
  * Check if the specified matrix is symmetric.
  * The error message is either 0 or 1 indexed, specified by
  * <code>stan::error_index::value</code>.
- * @tparam T_y Type of scalar
+ * @tparam EigMat Type of matrix
  * @param function Function name (for error messages)
  * @param name Variable name (for error messages)
  * @param y Matrix to test
@@ -27,21 +27,18 @@ namespace math {
  * @throw <code>std::domain_error</code> if any element not on the
  *   main diagonal is <code>NaN</code>
  */
-template <typename T_y>
-inline void check_symmetric(
-    const char* function, const char* name,
-    const Eigen::Matrix<T_y, Eigen::Dynamic, Eigen::Dynamic>& y) {
+template <typename EigMat, require_eigen_t<EigMat>* = nullptr>
+inline void check_symmetric(const char* function, const char* name,
+                            const EigMat& y) {
   check_square(function, name, y);
   using std::fabs;
-  using size_type
-      = index_type_t<Eigen::Matrix<T_y, Eigen::Dynamic, Eigen::Dynamic>>;
 
-  size_type k = y.rows();
+  Eigen::Index k = y.rows();
   if (k <= 1) {
     return;
   }
-  for (size_type m = 0; m < k; ++m) {
-    for (size_type n = m + 1; n < k; ++n) {
+  for (Eigen::Index m = 0; m < k; ++m) {
+    for (Eigen::Index n = m + 1; n < k; ++n) {
       if (!(fabs(value_of(y(m, n)) - value_of(y(n, m)))
             <= CONSTRAINT_TOLERANCE)) {
         std::ostringstream msg1;
diff --git a/stan/math/prim/fun/cholesky_decompose.hpp b/stan/math/prim/fun/cholesky_decompose.hpp
index 571fa106f8c..c382bd84d09 100644
--- a/stan/math/prim/fun/cholesky_decompose.hpp
+++ b/stan/math/prim/fun/cholesky_decompose.hpp
@@ -35,7 +35,7 @@ template <typename EigMat, require_eigen_t<EigMat>* = nullptr,
 inline Eigen::Matrix<value_type_t<EigMat>, EigMat::RowsAtCompileTime,
                      EigMat::ColsAtCompileTime>
 cholesky_decompose(const EigMat& m) {
-  eval_return_type_t<EigMat>& m_eval = m.eval();
+  const eval_return_type_t<EigMat>& m_eval = m.eval();
   check_symmetric("cholesky_decompose", "m", m_eval);
   check_not_nan("cholesky_decompose", "m", m_eval);
   Eigen::LLT<Eigen::Matrix<value_type_t<EigMat>, EigMat::RowsAtCompileTime,
@@ -66,7 +66,7 @@ template <typename EigMat, require_eigen_t<EigMat>* = nullptr,
 inline Eigen::Matrix<double, EigMat::RowsAtCompileTime,
                      EigMat::ColsAtCompileTime>
 cholesky_decompose(const EigMat& m) {
-  eval_return_type_t<EigMat>& m_eval = m.eval();
+  const eval_return_type_t<EigMat>& m_eval = m.eval();
   check_not_nan("cholesky_decompose", "m", m_eval);
 #ifdef STAN_OPENCL
   if (m.rows() >= opencl_context.tuning_opts().cholesky_size_worth_transfer) {
diff --git a/stan/math/prim/fun/inverse_spd.hpp b/stan/math/prim/fun/inverse_spd.hpp
index c34f9f3c020..f91117ef03f 100644
--- a/stan/math/prim/fun/inverse_spd.hpp
+++ b/stan/math/prim/fun/inverse_spd.hpp
@@ -25,11 +25,11 @@ inverse_spd(const EigMat& m) {
   using Eigen::LDLT;
   using Eigen::Matrix;
   using Scalar = value_type_t<EigMat>;
-  check_symmetric("inverse_spd", "m", m);
   if (m.size() == 0) {
     return {};
   }
   const Eigen::Ref<const plain_type_t<EigMat>>& m_ref = m;
+  check_symmetric("inverse_spd", "m", m_ref);
   plain_type_t<EigMat> mmt = 0.5 * (m_ref + m_ref.transpose());
   LDLT<plain_type_t<EigMat>> ldlt(mmt);
   if (ldlt.info() != Eigen::Success) {
diff --git a/stan/math/prim/fun/log_determinant_spd.hpp b/stan/math/prim/fun/log_determinant_spd.hpp
index f3b04a4e6d3..738817a78b1 100644
--- a/stan/math/prim/fun/log_determinant_spd.hpp
+++ b/stan/math/prim/fun/log_determinant_spd.hpp
@@ -5,6 +5,7 @@
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/log.hpp>
 #include <stan/math/prim/fun/sum.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <cmath>
 
 namespace stan {
@@ -22,11 +23,12 @@ namespace math {
 template <typename EigMat, require_eigen_t<EigMat>* = nullptr,
           require_not_vt_var<EigMat>* = nullptr>
 inline value_type_t<EigMat> log_determinant_spd(const EigMat& m) {
-  check_symmetric("log_determinant_spd", "m", m);
+  const auto& m_ref = to_ref(m);
+  check_symmetric("log_determinant_spd", "m", m_ref);
   if (m.size() == 0) {
     return 0;
   }
-  return sum(log(m.ldlt().vectorD().array()));
+  return sum(log(m_ref.ldlt().vectorD().array()));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_mix.hpp b/stan/math/prim/fun/log_mix.hpp
index d6ecf369eb8..f8df7d10895 100644
--- a/stan/math/prim/fun/log_mix.hpp
+++ b/stan/math/prim/fun/log_mix.hpp
@@ -77,22 +77,26 @@ return_type_t<T_theta, T_lam> log_mix(const T_theta& theta,
   using T_partials_return = partials_return_t<T_theta, T_lam>;
   using T_partials_vec =
       typename Eigen::Matrix<T_partials_return, Eigen::Dynamic, 1>;
+  using T_theta_ref = ref_type_t<T_theta>;
+  using T_lam_ref = ref_type_t<T_lam>;
 
   const int N = stan::math::size(theta);
 
-  check_bounded(function, "theta", theta, 0, 1);
-  check_not_nan(function, "lambda", lambda);
-  check_not_nan(function, "theta", theta);
-  check_finite(function, "lambda", lambda);
-  check_finite(function, "theta", theta);
   check_consistent_sizes(function, "theta", theta, "lambda", lambda);
+  T_theta_ref theta_ref = theta;
+  T_lam_ref lambda_ref = lambda;
+  check_bounded(function, "theta", theta_ref, 0, 1);
+  check_finite(function, "lambda", lambda_ref);
 
-  const auto& theta_dbl = to_ref(value_of(as_column_vector_or_scalar(theta)));
-  const auto& lam_dbl = to_ref(value_of(as_column_vector_or_scalar(lambda)));
+  const auto& theta_dbl
+      = to_ref(value_of(as_column_vector_or_scalar(theta_ref)));
+  const auto& lam_dbl
+      = to_ref(value_of(as_column_vector_or_scalar(lambda_ref)));
 
   T_partials_return logp = log_sum_exp(log(theta_dbl) + lam_dbl);
 
-  operands_and_partials<T_theta, T_lam> ops_partials(theta, lambda);
+  operands_and_partials<T_theta_ref, T_lam_ref> ops_partials(theta_ref,
+                                                             lambda_ref);
   if (!is_constant_all<T_lam, T_theta>::value) {
     T_partials_vec theta_deriv = (lam_dbl.array() - logp).exp();
     if (!is_constant_all<T_lam>::value) {
@@ -146,20 +150,21 @@ return_type_t<T_theta, std::vector<T_lam>> log_mix(
   using T_partials_mat =
       typename Eigen::Matrix<T_partials_return, Eigen::Dynamic, Eigen::Dynamic>;
   using T_lamvec_type = typename std::vector<T_lam>;
+  using T_theta_ref = ref_type_t<T_theta>;
 
   const int N = stan::math::size(lambda);
   const int M = theta.size();
 
-  check_bounded(function, "theta", theta, 0, 1);
-  check_not_nan(function, "theta", theta);
-  check_finite(function, "theta", theta);
+  T_theta_ref theta_ref = theta;
+  check_bounded(function, "theta", theta_ref, 0, 1);
   for (int n = 0; n < N; ++n) {
     check_not_nan(function, "lambda", lambda[n]);
     check_finite(function, "lambda", lambda[n]);
     check_consistent_sizes(function, "theta", theta, "lambda", lambda[n]);
   }
 
-  const auto& theta_dbl = to_ref(value_of(as_column_vector_or_scalar(theta)));
+  const auto& theta_dbl
+      = to_ref(value_of(as_column_vector_or_scalar(theta_ref)));
 
   T_partials_mat lam_dbl(M, N);
   for (int n = 0; n < N; ++n) {
@@ -172,7 +177,8 @@ return_type_t<T_theta, std::vector<T_lam>> log_mix(
     logp[n] = log_sum_exp(logp_tmp.col(n));
   }
 
-  operands_and_partials<T_theta, T_lamvec_type> ops_partials(theta, lambda);
+  operands_and_partials<T_theta_ref, T_lamvec_type> ops_partials(theta_ref,
+                                                                 lambda);
   if (!is_constant_all<T_theta, T_lam>::value) {
     T_partials_mat derivs = exp(lam_dbl.rowwise() - logp.transpose());
     if (!is_constant_all<T_theta>::value) {
diff --git a/stan/math/prim/fun/mdivide_left_spd.hpp b/stan/math/prim/fun/mdivide_left_spd.hpp
index 89d7675d7ae..f403f40f5b9 100644
--- a/stan/math/prim/fun/mdivide_left_spd.hpp
+++ b/stan/math/prim/fun/mdivide_left_spd.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 
 namespace stan {
 namespace math {
@@ -22,21 +23,24 @@ namespace math {
  * match the size of A.
  */
 template <typename EigMat1, typename EigMat2,
-          require_all_eigen_t<EigMat1, EigMat2>* = nullptr>
+          require_all_eigen_t<EigMat1, EigMat2>* = nullptr,
+          require_all_not_vt_var<EigMat1, EigMat2>* = nullptr>
 inline Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
                      EigMat1::RowsAtCompileTime, EigMat2::ColsAtCompileTime>
 mdivide_left_spd(const EigMat1& A, const EigMat2& b) {
   static const char* function = "mdivide_left_spd";
   check_multiplicable(function, "A", A, "b", b);
-  check_symmetric(function, "A", A);
-  check_not_nan(function, "A", A);
+  const auto& A_ref = to_ref(A);
+  check_symmetric(function, "A", A_ref);
+  check_not_nan(function, "A", A_ref);
   if (A.size() == 0) {
     return {0, b.cols()};
   }
 
   auto llt
       = Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
-                      EigMat1::RowsAtCompileTime, EigMat1::ColsAtCompileTime>(A)
+                      EigMat1::RowsAtCompileTime, EigMat1::ColsAtCompileTime>(
+            A_ref)
             .llt();
   check_pos_definite(function, "A", llt);
   return llt.solve(
diff --git a/stan/math/prim/fun/mdivide_left_tri.hpp b/stan/math/prim/fun/mdivide_left_tri.hpp
index b903916d9a2..a3ac9227b7b 100644
--- a/stan/math/prim/fun/mdivide_left_tri.hpp
+++ b/stan/math/prim/fun/mdivide_left_tri.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #ifdef STAN_OPENCL
 #include <stan/math/opencl/opencl.hpp>
 #endif
@@ -104,7 +105,7 @@ mdivide_left_tri(const T1 &A, const T2 &b) {
     return from_matrix_cl(C_cl);
   } else {
 #endif
-    return A.template triangularView<TriView>().solve(b);
+    return to_ref(A).template triangularView<TriView>().solve(b);
 #ifdef STAN_OPENCL
   }
 #endif
diff --git a/stan/math/prim/fun/mdivide_right_spd.hpp b/stan/math/prim/fun/mdivide_right_spd.hpp
index d164f71af5e..c874b78bbc4 100644
--- a/stan/math/prim/fun/mdivide_right_spd.hpp
+++ b/stan/math/prim/fun/mdivide_right_spd.hpp
@@ -5,6 +5,7 @@
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/mdivide_left_spd.hpp>
 #include <stan/math/prim/fun/transpose.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 
 namespace stan {
 namespace math {
@@ -29,13 +30,14 @@ inline Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
 mdivide_right_spd(const EigMat1& b, const EigMat2& A) {
   static const char* function = "mdivide_right_spd";
   check_multiplicable(function, "b", b, "A", A);
-  check_symmetric(function, "A", A);
-  check_not_nan(function, "A", A);
+  const auto& A_ref = to_ref(A);
+  check_symmetric(function, "A", A_ref);
+  check_not_nan(function, "A", A_ref);
   if (A.size() == 0) {
     return {b.rows(), 0};
   }
 
-  return mdivide_left_spd(A, b.transpose()).transpose();
+  return mdivide_left_spd(A_ref, b.transpose()).transpose();
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/mdivide_right_tri.hpp b/stan/math/prim/fun/mdivide_right_tri.hpp
index 82257ac2e38..404833176da 100644
--- a/stan/math/prim/fun/mdivide_right_tri.hpp
+++ b/stan/math/prim/fun/mdivide_right_tri.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #ifdef STAN_OPENCL
 #include <stan/math/opencl/opencl.hpp>
 #endif
@@ -94,7 +95,8 @@ mdivide_right_tri(const EigMat1& b, const EigMat2& A) {
     return from_matrix_cl(C_cl);
   } else {
 #endif
-    return A.template triangularView<TriView>()
+    return to_ref(A)
+        .template triangularView<TriView>()
         .transpose()
         .solve(b.transpose())
         .transpose();
diff --git a/stan/math/prim/fun/quad_form.hpp b/stan/math/prim/fun/quad_form.hpp
index 803d3d1fca9..1177fd66c92 100644
--- a/stan/math/prim/fun/quad_form.hpp
+++ b/stan/math/prim/fun/quad_form.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 
 namespace stan {
 namespace math {
@@ -32,7 +33,8 @@ inline Eigen::Matrix<value_type_t<EigMat2>, EigMat2::ColsAtCompileTime,
 quad_form(const EigMat1& A, const EigMat2& B) {
   check_square("quad_form", "A", A);
   check_multiplicable("quad_form", "A", A, "B", B);
-  return B.transpose() * A * B;
+  const auto& B_ref = to_ref(B);
+  return B_ref.transpose() * A * B_ref;
 }
 
 /**
@@ -54,7 +56,8 @@ template <typename EigMat, typename ColVec, require_eigen_t<EigMat>* = nullptr,
 inline value_type_t<EigMat> quad_form(const EigMat& A, const ColVec& B) {
   check_square("quad_form", "A", A);
   check_multiplicable("quad_form", "A", A, "B", B);
-  return B.dot(A * B);
+  const auto& B_ref = to_ref(B);
+  return B_ref.dot(A * B_ref);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/quad_form_sym.hpp b/stan/math/prim/fun/quad_form_sym.hpp
index f9738c7ca43..7c367d5dda6 100644
--- a/stan/math/prim/fun/quad_form_sym.hpp
+++ b/stan/math/prim/fun/quad_form_sym.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 
 namespace stan {
 namespace math {
@@ -28,8 +29,10 @@ template <typename EigMat1, typename EigMat2,
           require_all_vt_arithmetic<EigMat1, EigMat2>* = nullptr>
 inline plain_type_t<EigMat2> quad_form_sym(const EigMat1& A, const EigMat2& B) {
   check_multiplicable("quad_form_sym", "A", A, "B", B);
-  check_symmetric("quad_form_sym", "A", A);
-  plain_type_t<EigMat2> ret(B.transpose() * A * B);
+  const auto& A_ref = to_ref(A);
+  const auto& B_ref = to_ref(B);
+  check_symmetric("quad_form_sym", "A", A_ref);
+  plain_type_t<EigMat2> ret(B_ref.transpose() * A_ref * B_ref);
   return value_type_t<EigMat2>(0.5) * (ret + ret.transpose());
 }
 
@@ -51,8 +54,10 @@ template <typename EigMat, typename ColVec, require_eigen_t<EigMat>* = nullptr,
           require_all_vt_arithmetic<EigMat, ColVec>* = nullptr>
 inline value_type_t<EigMat> quad_form_sym(const EigMat& A, const ColVec& B) {
   check_multiplicable("quad_form_sym", "A", A, "B", B);
-  check_symmetric("quad_form_sym", "A", A);
-  return B.dot(A * B);
+  const auto& A_ref = to_ref(A);
+  const auto& B_ref = to_ref(B);
+  check_symmetric("quad_form_sym", "A", A_ref);
+  return B_ref.dot(A_ref * B_ref);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/softmax.hpp b/stan/math/prim/fun/softmax.hpp
index ccc5c8c0809..2624bcdae39 100644
--- a/stan/math/prim/fun/softmax.hpp
+++ b/stan/math/prim/fun/softmax.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <cmath>
 
 namespace stan {
@@ -46,7 +47,8 @@ template <typename ColVec,
 inline plain_type_t<ColVec> softmax(const ColVec& v) {
   using std::exp;
   check_nonzero_size("softmax", "v", v);
-  plain_type_t<ColVec> theta = (v.array() - v.maxCoeff()).exp();
+  const auto& v_ref = to_ref(v);
+  plain_type_t<ColVec> theta = (v_ref.array() - v_ref.maxCoeff()).exp();
   return theta.array() / theta.sum();
 }
 
diff --git a/stan/math/prim/fun/sort_indices.hpp b/stan/math/prim/fun/sort_indices.hpp
index e80e8d2d001..a77800927c3 100644
--- a/stan/math/prim/fun/sort_indices.hpp
+++ b/stan/math/prim/fun/sort_indices.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <algorithm>
 #include <vector>
 
@@ -68,7 +69,7 @@ std::vector<int> sort_indices(const C& xs) {
   for (idx_t i = 0; i < xs_size; ++i) {
     idxs[i] = i + 1;
   }
-  internal::index_comparator<ascending, C> comparator(xs);
+  internal::index_comparator<ascending, ref_type_t<C>> comparator(to_ref(xs));
   std::sort(idxs.begin(), idxs.end(), comparator);
   return idxs;
 }
diff --git a/stan/math/prim/fun/tcrossprod.hpp b/stan/math/prim/fun/tcrossprod.hpp
index c558c282083..532465d355e 100644
--- a/stan/math/prim/fun/tcrossprod.hpp
+++ b/stan/math/prim/fun/tcrossprod.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
 
 namespace stan {
@@ -23,13 +24,14 @@ tcrossprod(const T& M) {
   if (M.rows() == 0) {
     return {};
   }
+  const auto& M_ref = to_ref(M);
   if (M.rows() == 1) {
-    return M * M.transpose();
+    return M_ref * M_ref.transpose();
   }
   Eigen::Matrix<value_type_t<T>, T::RowsAtCompileTime, T::RowsAtCompileTime>
       result(M.rows(), M.rows());
   return result.setZero().template selfadjointView<Eigen::Upper>().rankUpdate(
-      M);
+      M_ref);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/trace_gen_quad_form.hpp b/stan/math/prim/fun/trace_gen_quad_form.hpp
index b65cd7f71a2..dee94ad21e8 100644
--- a/stan/math/prim/fun/trace_gen_quad_form.hpp
+++ b/stan/math/prim/fun/trace_gen_quad_form.hpp
@@ -6,6 +6,7 @@
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/trace.hpp>
 #include <stan/math/prim/fun/multiply.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/transpose.hpp>
 #include <exception>
 
@@ -37,7 +38,8 @@ inline auto trace_gen_quad_form(const TD &D, const TA &A, const TB &B) {
   check_square("trace_gen_quad_form", "D", D);
   check_multiplicable("trace_gen_quad_form", "A", A, "B", B);
   check_multiplicable("trace_gen_quad_form", "B", B, "D", D);
-  return multiply(B, D.transpose()).cwiseProduct(multiply(A, B)).sum();
+  const auto &B_ref = to_ref(B);
+  return multiply(B_ref, D.transpose()).cwiseProduct(multiply(A, B_ref)).sum();
 }
 
 /**
@@ -65,7 +67,8 @@ inline double trace_gen_quad_form(const TD &D, const TA &A, const TB &B) {
   check_square("trace_gen_quad_form", "D", D);
   check_multiplicable("trace_gen_quad_form", "A", A, "B", B);
   check_multiplicable("trace_gen_quad_form", "B", B, "D", D);
-  return (B * D.transpose()).cwiseProduct(A * B).sum();
+  const auto &B_ref = to_ref(B);
+  return (B_ref * D.transpose()).cwiseProduct(A * B_ref).sum();
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/trace_quad_form.hpp b/stan/math/prim/fun/trace_quad_form.hpp
index 5a48fc8ce43..73b7f38b148 100644
--- a/stan/math/prim/fun/trace_quad_form.hpp
+++ b/stan/math/prim/fun/trace_quad_form.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 
 namespace stan {
 namespace math {
@@ -26,8 +27,8 @@ inline return_type_t<EigMat1, EigMat2> trace_quad_form(const EigMat1& A,
                                                        const EigMat2& B) {
   check_square("trace_quad_form", "A", A);
   check_multiplicable("trace_quad_form", "A", A, "B", B);
-
-  return B.cwiseProduct(A * B).sum();
+  const auto& B_ref = to_ref(B);
+  return B_ref.cwiseProduct(A * B_ref).sum();
 }
 
 }  // namespace math
diff --git a/stan/math/prim/prob/categorical_logit_glm_lpmf.hpp b/stan/math/prim/prob/categorical_logit_glm_lpmf.hpp
index 94a368f0d5a..fa745ece797 100644
--- a/stan/math/prim/prob/categorical_logit_glm_lpmf.hpp
+++ b/stan/math/prim/prob/categorical_logit_glm_lpmf.hpp
@@ -114,9 +114,9 @@ return_type_t<T_x, T_alpha, T_beta> categorical_logit_glm_lpmf(
   // lin(Eigen::all,y-1).sum() + log(inv_sum_exp_lin).sum() - lin_max.sum();
 
   if (!std::isfinite(logp)) {
-    check_finite(function, "Weight vector", beta);
-    check_finite(function, "Intercept", alpha);
-    check_finite(function, "Matrix of independent variables", x);
+    check_finite(function, "Weight vector", beta_ref);
+    check_finite(function, "Intercept", alpha_ref);
+    check_finite(function, "Matrix of independent variables", x_ref);
   }
 
   // Compute the derivatives.
diff --git a/stan/math/prim/prob/neg_binomial_2_log_glm_lpmf.hpp b/stan/math/prim/prob/neg_binomial_2_log_glm_lpmf.hpp
index cf2943bad34..f893066b83f 100644
--- a/stan/math/prim/prob/neg_binomial_2_log_glm_lpmf.hpp
+++ b/stan/math/prim/prob/neg_binomial_2_log_glm_lpmf.hpp
@@ -103,8 +103,8 @@ return_type_t<T_x, T_alpha, T_beta, T_precision> neg_binomial_2_log_glm_lpmf(
   const auto& alpha_val = value_of_rec(alpha_ref);
   const auto& beta_val_vec = to_ref(as_column_vector_or_scalar(beta_val));
   const auto& alpha_val_vec = to_ref(as_column_vector_or_scalar(alpha_val));
-  check_finite(function, "Weight vector", beta_ref);
-  check_finite(function, "Intercept", alpha_ref);
+  check_finite(function, "Weight vector", beta_val_vec);
+  check_finite(function, "Intercept", alpha_val_vec);
 
   if (size_zero(y, phi)) {
     return 0;
diff --git a/stan/math/rev/fun/cholesky_decompose.hpp b/stan/math/rev/fun/cholesky_decompose.hpp
index fd5f0996f28..c17a3ab9fda 100644
--- a/stan/math/rev/fun/cholesky_decompose.hpp
+++ b/stan/math/rev/fun/cholesky_decompose.hpp
@@ -8,6 +8,7 @@
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/cholesky_decompose.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
 #include <stan/math/prim/fun/value_of_rec.hpp>
 
@@ -377,8 +378,9 @@ class cholesky_opencl : public vari {
 template <typename T, require_eigen_vt<is_var, T>* = nullptr>
 inline Eigen::Matrix<var, T::RowsAtCompileTime, T::ColsAtCompileTime>
 cholesky_decompose(const T& A) {
+  const auto& A_ref = to_ref(A);
   Eigen::Matrix<double, T::RowsAtCompileTime, T::ColsAtCompileTime> L_A(
-      value_of_rec(A));
+      value_of_rec(A_ref));
   check_not_nan("cholesky_decompose", "A", L_A);
 #ifdef STAN_OPENCL
   L_A = cholesky_decompose(L_A);
@@ -394,7 +396,7 @@ cholesky_decompose(const T& A) {
   Eigen::Matrix<var, T::RowsAtCompileTime, T::ColsAtCompileTime> L(A.rows(),
                                                                    A.cols());
   if (L_A.rows() <= 35) {
-    cholesky_scalar* baseVari = new cholesky_scalar(A, L_A);
+    cholesky_scalar* baseVari = new cholesky_scalar(A_ref, L_A);
     size_t accum = 0;
     size_t accum_i = accum;
     for (size_type j = 0; j < L.cols(); ++j) {
@@ -413,14 +415,14 @@ cholesky_decompose(const T& A) {
 #ifdef STAN_OPENCL
     if (L_A.rows()
         > opencl_context.tuning_opts().cholesky_size_worth_transfer) {
-      cholesky_opencl* baseVari = new cholesky_opencl(A, L_A);
+      cholesky_opencl* baseVari = new cholesky_opencl(A_ref, L_A);
       internal::set_lower_tri_coeff_ref(L, baseVari->vari_ref_L_);
     } else {
-      cholesky_block* baseVari = new cholesky_block(A, L_A);
+      cholesky_block* baseVari = new cholesky_block(A_ref, L_A);
       internal::set_lower_tri_coeff_ref(L, baseVari->vari_ref_L_);
     }
 #else
-    cholesky_block* baseVari = new cholesky_block(A, L_A);
+    cholesky_block* baseVari = new cholesky_block(A_ref, L_A);
     internal::set_lower_tri_coeff_ref(L, baseVari->vari_ref_L_);
 #endif
   }
diff --git a/stan/math/rev/fun/log_determinant_spd.hpp b/stan/math/rev/fun/log_determinant_spd.hpp
index f07e60b83a6..215326acd01 100644
--- a/stan/math/rev/fun/log_determinant_spd.hpp
+++ b/stan/math/rev/fun/log_determinant_spd.hpp
@@ -21,12 +21,12 @@ namespace math {
  */
 template <typename EigMat, require_eigen_vt<is_var, EigMat>* = nullptr>
 inline var log_determinant_spd(const EigMat& m) {
-  check_symmetric("log_determinant_spd", "m", m);
   if (m.size() == 0) {
     return 0;
   }
 
   matrix_d m_d = m.val();
+  check_symmetric("log_determinant_spd", "m", m_d);
 
   Eigen::LDLT<matrix_d> ldlt(m_d);
   if (ldlt.info() != Eigen::Success) {
diff --git a/stan/math/rev/fun/log_softmax.hpp b/stan/math/rev/fun/log_softmax.hpp
index 16d60be2479..bad74768d9f 100644
--- a/stan/math/rev/fun/log_softmax.hpp
+++ b/stan/math/rev/fun/log_softmax.hpp
@@ -8,6 +8,7 @@
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/fun/log_softmax.hpp>
 #include <stan/math/prim/fun/softmax.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
 #include <cmath>
 #include <vector>
@@ -57,39 +58,40 @@ class log_softmax_elt_vari : public vari {
  */
 template <typename T, require_container_st<is_var, T>* = nullptr>
 inline auto log_softmax(const T& x) {
-  return apply_vector_unary<T>::apply(x, [&](const auto& alpha) {
-    const int a_size = alpha.size();
+  return apply_vector_unary<ref_type_t<T>>::apply(
+      to_ref(x), [&](const auto& alpha) {
+        const int a_size = alpha.size();
 
-    check_nonzero_size("log_softmax", "alpha", alpha);
+        check_nonzero_size("log_softmax", "alpha", alpha);
 
-    vari** alpha_vi_array
-        = ChainableStack::instance_->memalloc_.alloc_array<vari*>(a_size);
-    Eigen::Map<vector_vi>(alpha_vi_array, a_size) = alpha.vi();
+        vari** alpha_vi_array
+            = ChainableStack::instance_->memalloc_.alloc_array<vari*>(a_size);
+        Eigen::Map<vector_vi>(alpha_vi_array, a_size) = alpha.vi();
 
-    vector_d alpha_d = alpha.val();
+        vector_d alpha_d = alpha.val();
 
-    // fold logic of math::softmax() and math::log_softmax()
-    // to save computations
+        // fold logic of math::softmax() and math::log_softmax()
+        // to save computations
 
-    vector_d diff = (alpha_d.array() - alpha_d.maxCoeff());
-    vector_d softmax_alpha_d = diff.array().exp();
-    double sum = softmax_alpha_d.sum();
-    vector_d log_softmax_alpha_d = diff.array() - std::log(sum);
+        vector_d diff = (alpha_d.array() - alpha_d.maxCoeff());
+        vector_d softmax_alpha_d = diff.array().exp();
+        double sum = softmax_alpha_d.sum();
+        vector_d log_softmax_alpha_d = diff.array() - std::log(sum);
 
-    // end fold
-    double* softmax_alpha_d_array
-        = ChainableStack::instance_->memalloc_.alloc_array<double>(a_size);
-    Eigen::Map<vector_d>(softmax_alpha_d_array, a_size)
-        = softmax_alpha_d.array() / sum;
+        // end fold
+        double* softmax_alpha_d_array
+            = ChainableStack::instance_->memalloc_.alloc_array<double>(a_size);
+        Eigen::Map<vector_d>(softmax_alpha_d_array, a_size)
+            = softmax_alpha_d.array() / sum;
 
-    vector_v log_softmax_alpha(a_size);
-    for (int k = 0; k < a_size; ++k) {
-      log_softmax_alpha(k) = var(new internal::log_softmax_elt_vari(
-          log_softmax_alpha_d[k], alpha_vi_array, softmax_alpha_d_array, a_size,
-          k));
-    }
-    return log_softmax_alpha;
-  });
+        vector_v log_softmax_alpha(a_size);
+        for (int k = 0; k < a_size; ++k) {
+          log_softmax_alpha(k) = var(new internal::log_softmax_elt_vari(
+              log_softmax_alpha_d[k], alpha_vi_array, softmax_alpha_d_array,
+              a_size, k));
+        }
+        return log_softmax_alpha;
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/rev/fun/mdivide_left_spd.hpp b/stan/math/rev/fun/mdivide_left_spd.hpp
index c223e412cb9..0d5d9a50694 100644
--- a/stan/math/rev/fun/mdivide_left_spd.hpp
+++ b/stan/math/rev/fun/mdivide_left_spd.hpp
@@ -6,6 +6,7 @@
 #include <stan/math/rev/fun/typedefs.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
 #include <vector>
 
@@ -143,13 +144,21 @@ class mdivide_left_spd_vd_vari : public vari {
 };
 }  // namespace internal
 
-template <int R1, int C1, int R2, int C2>
-inline Eigen::Matrix<var, R1, C2> mdivide_left_spd(
-    const Eigen::Matrix<var, R1, C1> &A, const Eigen::Matrix<var, R2, C2> &b) {
+template <
+    typename EigMat1, typename EigMat2,
+    require_all_eigen_matrix_base_vt<is_var, EigMat1, EigMat2> * = nullptr>
+inline Eigen::Matrix<var, EigMat1::RowsAtCompileTime,
+                     EigMat2::ColsAtCompileTime>
+mdivide_left_spd(const EigMat1 &A, const EigMat2 &b) {
+  constexpr int R1 = EigMat1::RowsAtCompileTime;
+  constexpr int C1 = EigMat1::ColsAtCompileTime;
+  constexpr int R2 = EigMat2::RowsAtCompileTime;
+  constexpr int C2 = EigMat2::ColsAtCompileTime;
   static const char *function = "mdivide_left_spd";
   check_multiplicable(function, "A", A, "b", b);
-  check_symmetric(function, "A", A);
-  check_not_nan(function, "A", A);
+  const auto &A_ref = to_ref(A);
+  check_symmetric(function, "A", A_ref);
+  check_not_nan(function, "A", A_ref);
   if (A.size() == 0) {
     return {0, b.cols()};
   }
@@ -159,21 +168,28 @@ inline Eigen::Matrix<var, R1, C2> mdivide_left_spd(
   // for the returned matrix.  Memory will be cleaned up with the
   // arena allocator.
   internal::mdivide_left_spd_vv_vari<R1, C1, R2, C2> *baseVari
-      = new internal::mdivide_left_spd_vv_vari<R1, C1, R2, C2>(A, b);
+      = new internal::mdivide_left_spd_vv_vari<R1, C1, R2, C2>(A_ref, b);
 
   Eigen::Matrix<var, R1, C2> res(b.rows(), b.cols());
   res.vi() = Eigen::Map<matrix_vi>(&baseVari->variRefC_[0], b.rows(), b.cols());
   return res;
 }
 
-template <int R1, int C1, int R2, int C2>
-inline Eigen::Matrix<var, R1, C2> mdivide_left_spd(
-    const Eigen::Matrix<var, R1, C1> &A,
-    const Eigen::Matrix<double, R2, C2> &b) {
+template <typename EigMat1, typename EigMat2,
+          require_eigen_matrix_base_vt<is_var, EigMat1> * = nullptr,
+          require_eigen_matrix_base_vt<std::is_arithmetic, EigMat2> * = nullptr>
+inline Eigen::Matrix<var, EigMat1::RowsAtCompileTime,
+                     EigMat2::ColsAtCompileTime>
+mdivide_left_spd(const EigMat1 &A, const EigMat2 &b) {
+  constexpr int R1 = EigMat1::RowsAtCompileTime;
+  constexpr int C1 = EigMat1::ColsAtCompileTime;
+  constexpr int R2 = EigMat2::RowsAtCompileTime;
+  constexpr int C2 = EigMat2::ColsAtCompileTime;
   static const char *function = "mdivide_left_spd";
   check_multiplicable(function, "A", A, "b", b);
-  check_symmetric(function, "A", A);
-  check_not_nan(function, "A", A);
+  const auto &A_ref = to_ref(A);
+  check_symmetric(function, "A", A_ref);
+  check_not_nan(function, "A", A_ref);
   if (A.size() == 0) {
     return {0, b.cols()};
   }
@@ -183,21 +199,28 @@ inline Eigen::Matrix<var, R1, C2> mdivide_left_spd(
   // for the returned matrix.  Memory will be cleaned up with the
   // arena allocator.
   internal::mdivide_left_spd_vd_vari<R1, C1, R2, C2> *baseVari
-      = new internal::mdivide_left_spd_vd_vari<R1, C1, R2, C2>(A, b);
+      = new internal::mdivide_left_spd_vd_vari<R1, C1, R2, C2>(A_ref, b);
 
   Eigen::Matrix<var, R1, C2> res(b.rows(), b.cols());
   res.vi() = Eigen::Map<matrix_vi>(&baseVari->variRefC_[0], b.rows(), b.cols());
   return res;
 }
 
-template <int R1, int C1, int R2, int C2>
-inline Eigen::Matrix<var, R1, C2> mdivide_left_spd(
-    const Eigen::Matrix<double, R1, C1> &A,
-    const Eigen::Matrix<var, R2, C2> &b) {
+template <typename EigMat1, typename EigMat2,
+          require_eigen_matrix_base_vt<std::is_arithmetic, EigMat1> * = nullptr,
+          require_eigen_matrix_base_vt<is_var, EigMat2> * = nullptr>
+inline Eigen::Matrix<var, EigMat1::RowsAtCompileTime,
+                     EigMat2::ColsAtCompileTime>
+mdivide_left_spd(const EigMat1 &A, const EigMat2 &b) {
+  constexpr int R1 = EigMat1::RowsAtCompileTime;
+  constexpr int C1 = EigMat1::ColsAtCompileTime;
+  constexpr int R2 = EigMat2::RowsAtCompileTime;
+  constexpr int C2 = EigMat2::ColsAtCompileTime;
   static const char *function = "mdivide_left_spd";
   check_multiplicable(function, "A", A, "b", b);
-  check_symmetric(function, "A", A);
-  check_not_nan(function, "A", A);
+  const auto &A_ref = to_ref(A);
+  check_symmetric(function, "A", A_ref);
+  check_not_nan(function, "A", A_ref);
   if (A.size() == 0) {
     return {0, b.cols()};
   }
@@ -207,7 +230,7 @@ inline Eigen::Matrix<var, R1, C2> mdivide_left_spd(
   // for the returned matrix.  Memory will be cleaned up with the
   // arena allocator.
   internal::mdivide_left_spd_dv_vari<R1, C1, R2, C2> *baseVari
-      = new internal::mdivide_left_spd_dv_vari<R1, C1, R2, C2>(A, b);
+      = new internal::mdivide_left_spd_dv_vari<R1, C1, R2, C2>(A_ref, b);
 
   Eigen::Matrix<var, R1, C2> res(b.rows(), b.cols());
   res.vi() = Eigen::Map<matrix_vi>(&baseVari->variRefC_[0], b.rows(), b.cols());
diff --git a/stan/math/rev/fun/multiply.hpp b/stan/math/rev/fun/multiply.hpp
index d0e42ebc8b7..3bcdd2aabe5 100644
--- a/stan/math/rev/fun/multiply.hpp
+++ b/stan/math/rev/fun/multiply.hpp
@@ -563,12 +563,14 @@ inline auto multiply(const Mat1& m1, const Mat2& m2) {
   constexpr int Ca = Mat1::ColsAtCompileTime;
   constexpr int Cb = Mat2::ColsAtCompileTime;
   check_multiplicable("multiply", "m1", m1, "m2", m2);
-  check_not_nan("multiply", "m1", m1);
-  check_not_nan("multiply", "m2", m2);
+  const auto& m1_ref = to_ref(m1);
+  const auto& m2_ref = to_ref(m2);
+  check_not_nan("multiply", "m1", m1_ref);
+  check_not_nan("multiply", "m2", m2_ref);
 
   // Memory managed with the arena allocator.
   multiply_mat_vari<Ta, Ra, Ca, Tb, Cb>* baseVari
-      = new multiply_mat_vari<Ta, Ra, Ca, Tb, Cb>(m1, m2);
+      = new multiply_mat_vari<Ta, Ra, Ca, Tb, Cb>(m1_ref, m2_ref);
   Eigen::Matrix<var, Ra, Cb> AB_v(m1.rows(), m2.cols());
   AB_v.vi()
       = Eigen::Map<matrix_vi>(&baseVari->variRefAB_[0], m1.rows(), m2.cols());
@@ -596,12 +598,14 @@ inline var multiply(const RowVec& m1, const ColVec& m2) {
   using ColVecScalar = value_type_t<ColVec>;
   constexpr int Ca = RowVec::ColsAtCompileTime;
   check_multiplicable("multiply", "m1", m1, "m2", m2);
-  check_not_nan("multiply", "m1", m1);
-  check_not_nan("multiply", "m2", m2);
-
+  const auto& m1_ref = to_ref(m1);
+  const auto& m2_ref = to_ref(m2);
+  check_not_nan("multiply", "m1", m1_ref);
+  check_not_nan("multiply", "m2", m2_ref);
   // Memory managed with the arena allocator.
   multiply_mat_vari<RowVecScalar, 1, Ca, ColVecScalar, 1>* baseVari
-      = new multiply_mat_vari<RowVecScalar, 1, Ca, ColVecScalar, 1>(m1, m2);
+      = new multiply_mat_vari<RowVecScalar, 1, Ca, ColVecScalar, 1>(m1_ref,
+                                                                    m2_ref);
   var AB_v;
   AB_v.vi_ = baseVari->variRefAB_;
   return AB_v;
diff --git a/stan/math/rev/fun/quad_form_sym.hpp b/stan/math/rev/fun/quad_form_sym.hpp
index d84d3f95d94..055ae8a653a 100644
--- a/stan/math/rev/fun/quad_form_sym.hpp
+++ b/stan/math/rev/fun/quad_form_sym.hpp
@@ -5,6 +5,7 @@
 #include <stan/math/rev/core.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/rev/fun/quad_form.hpp>
 #include <type_traits>
 
@@ -31,8 +32,9 @@ template <typename EigMat1, typename EigMat2,
           require_any_vt_var<EigMat1, EigMat2>* = nullptr>
 inline auto quad_form_sym(const EigMat1& A, const EigMat2& B) {
   check_multiplicable("quad_form_sym", "A", A, "B", B);
-  check_symmetric("quad_form_sym", "A", A);
-  return quad_form(A, B);
+  const auto& A_ref = to_ref(A);
+  check_symmetric("quad_form_sym", "A", A_ref);
+  return quad_form(A_ref, B);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/fun/squared_distance.hpp b/stan/math/rev/fun/squared_distance.hpp
index 8515190e880..39655f6c08b 100644
--- a/stan/math/rev/fun/squared_distance.hpp
+++ b/stan/math/rev/fun/squared_distance.hpp
@@ -6,6 +6,7 @@
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/squared_distance.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 #include <stan/math/prim/fun/typedefs.hpp>
 #include <vector>
 
@@ -120,7 +121,7 @@ template <
     require_all_eigen_vector_vt<is_var, EigVecVar1, EigVecVar2>* = nullptr>
 inline var squared_distance(const EigVecVar1& v1, const EigVecVar2& v2) {
   check_matching_sizes("squared_distance", "v1", v1, "v2", v2);
-  return {new internal::squared_distance_vv_vari(v1, v2)};
+  return {new internal::squared_distance_vv_vari(to_ref(v1), to_ref(v2))};
 }
 
 template <typename EigVecVar, typename EigVecArith,
@@ -128,7 +129,7 @@ template <typename EigVecVar, typename EigVecArith,
           require_eigen_vector_vt<std::is_arithmetic, EigVecArith>* = nullptr>
 inline var squared_distance(const EigVecVar& v1, const EigVecArith& v2) {
   check_matching_sizes("squared_distance", "v1", v1, "v2", v2);
-  return {new internal::squared_distance_vd_vari(v1, v2)};
+  return {new internal::squared_distance_vd_vari(to_ref(v1), to_ref(v2))};
 }
 
 template <typename EigVecArith, typename EigVecVar,
@@ -136,7 +137,7 @@ template <typename EigVecArith, typename EigVecVar,
           require_eigen_vector_vt<is_var, EigVecVar>* = nullptr>
 inline var squared_distance(const EigVecArith& v1, const EigVecVar& v2) {
   check_matching_sizes("squared_distance", "v1", v1, "v2", v2);
-  return {new internal::squared_distance_vd_vari(v2, v1)};
+  return {new internal::squared_distance_vd_vari(to_ref(v2), to_ref(v1))};
 }
 
 }  // namespace math
diff --git a/test/expressions/stan_math_sigs_exceptions.expected b/test/expressions/stan_math_sigs_exceptions.expected
new file mode 100644
index 00000000000..d0b76e5f53a
--- /dev/null
+++ b/test/expressions/stan_math_sigs_exceptions.expected
@@ -0,0 +1,16137 @@
+vector algebra_solver((vector, vector, data real[], data int[]) => vector,
+                        vector, vector, real[], int[])
+vector algebra_solver((vector, vector, data real[], data int[]) => vector,
+                        vector, vector, real[], int[], real, real, real)
+vector algebra_solver_newton((vector, vector, data real[], data int[]) => vector,
+                               vector, vector, real[], int[])
+vector algebra_solver_newton((vector, vector, data real[], data int[]) => vector,
+                               vector, vector, real[], int[], real, real,
+                               real)
+void assign_add(vector, int)
+void assign_add(vector, real)
+void assign_add(vector, vector)
+void assign_add(row_vector, int)
+void assign_add(row_vector, real)
+void assign_add(row_vector, row_vector)
+void assign_add(matrix, int)
+void assign_add(matrix, real)
+void assign_add(matrix, matrix)
+void assign_divide(vector, int)
+void assign_divide(vector, real)
+void assign_divide(row_vector, int)
+void assign_divide(row_vector, real)
+void assign_divide(matrix, int)
+void assign_divide(matrix, real)
+void assign_elt_divide(vector, int)
+void assign_elt_divide(vector, real)
+void assign_elt_divide(vector, vector)
+void assign_elt_divide(row_vector, int)
+void assign_elt_divide(row_vector, real)
+void assign_elt_divide(row_vector, row_vector)
+void assign_elt_divide(matrix, int)
+void assign_elt_divide(matrix, real)
+void assign_elt_divide(matrix, matrix)
+void assign_elt_times(vector, vector)
+void assign_elt_times(row_vector, row_vector)
+void assign_elt_times(matrix, matrix)
+void assign_multiply(vector, int)
+void assign_multiply(vector, real)
+void assign_multiply(row_vector, int)
+void assign_multiply(row_vector, real)
+void assign_multiply(row_vector, matrix)
+void assign_multiply(matrix, int)
+void assign_multiply(matrix, real)
+void assign_multiply(matrix, matrix)
+void assign_subtract(int, int)
+void assign_subtract(real, int)
+void assign_subtract(real, real)
+void assign_subtract(vector, int)
+void assign_subtract(vector, real)
+void assign_subtract(vector, vector)
+void assign_subtract(row_vector, int)
+void assign_subtract(row_vector, real)
+void assign_subtract(row_vector, row_vector)
+void assign_subtract(matrix, int)
+void assign_subtract(matrix, real)
+void assign_subtract(matrix, matrix)
+real binomial_ccdf_log(int, int, vector)
+real binomial_ccdf_log(int, int, row_vector)
+real binomial_ccdf_log(int, int[], vector)
+real binomial_ccdf_log(int, int[], row_vector)
+real binomial_ccdf_log(int[], int, vector)
+real binomial_ccdf_log(int[], int, row_vector)
+real binomial_ccdf_log(int[], int[], vector)
+real binomial_ccdf_log(int[], int[], row_vector)
+real binomial_cdf(int, int, vector)
+real binomial_cdf(int, int, row_vector)
+real binomial_cdf(int, int[], vector)
+real binomial_cdf(int, int[], row_vector)
+real binomial_cdf(int[], int, vector)
+real binomial_cdf(int[], int, row_vector)
+real binomial_cdf(int[], int[], vector)
+real binomial_cdf(int[], int[], row_vector)
+real binomial_cdf_log(int, int, vector)
+real binomial_cdf_log(int, int, row_vector)
+real binomial_cdf_log(int, int[], vector)
+real binomial_cdf_log(int, int[], row_vector)
+real binomial_cdf_log(int[], int, vector)
+real binomial_cdf_log(int[], int, row_vector)
+real binomial_cdf_log(int[], int[], vector)
+real binomial_cdf_log(int[], int[], row_vector)
+real binomial_lccdf(int, int, vector)
+real binomial_lccdf(int, int, row_vector)
+real binomial_lccdf(int, int[], vector)
+real binomial_lccdf(int, int[], row_vector)
+real binomial_lccdf(int[], int, vector)
+real binomial_lccdf(int[], int, row_vector)
+real binomial_lccdf(int[], int[], vector)
+real binomial_lccdf(int[], int[], row_vector)
+real binomial_lcdf(int, int, vector)
+real binomial_lcdf(int, int, row_vector)
+real binomial_lcdf(int, int[], vector)
+real binomial_lcdf(int, int[], row_vector)
+real binomial_lcdf(int[], int, vector)
+real binomial_lcdf(int[], int, row_vector)
+real binomial_lcdf(int[], int[], vector)
+real binomial_lcdf(int[], int[], row_vector)
+real binomial_log(int, int, vector)
+real binomial_log(int, int, row_vector)
+real binomial_log(int, int[], vector)
+real binomial_log(int, int[], row_vector)
+real binomial_log(int[], int, vector)
+real binomial_log(int[], int, row_vector)
+real binomial_log(int[], int[], vector)
+real binomial_log(int[], int[], row_vector)
+real binomial_logit_log(int, int, vector)
+real binomial_logit_log(int, int, row_vector)
+real binomial_logit_log(int, int[], vector)
+real binomial_logit_log(int, int[], row_vector)
+real binomial_logit_log(int[], int, vector)
+real binomial_logit_log(int[], int, row_vector)
+real binomial_logit_log(int[], int[], vector)
+real binomial_logit_log(int[], int[], row_vector)
+real binomial_logit_lpmf(int, int, vector)
+real binomial_logit_lpmf(int, int, row_vector)
+real binomial_logit_lpmf(int, int[], vector)
+real binomial_logit_lpmf(int, int[], row_vector)
+real binomial_logit_lpmf(int[], int, vector)
+real binomial_logit_lpmf(int[], int, row_vector)
+real binomial_logit_lpmf(int[], int[], vector)
+real binomial_logit_lpmf(int[], int[], row_vector)
+real binomial_lpmf(int, int, vector)
+real binomial_lpmf(int, int, row_vector)
+real binomial_lpmf(int, int[], vector)
+real binomial_lpmf(int, int[], row_vector)
+real binomial_lpmf(int[], int, vector)
+real binomial_lpmf(int[], int, row_vector)
+real binomial_lpmf(int[], int[], vector)
+real binomial_lpmf(int[], int[], row_vector)
+int[] binomial_rng(int, vector)
+int[] binomial_rng(int, row_vector)
+int[] binomial_rng(int[], vector)
+int[] binomial_rng(int[], row_vector)
+matrix block(matrix, int, int, int, int)
+real categorical_log(int, vector)
+real categorical_log(int[], vector)
+real categorical_logit_log(int, vector)
+real categorical_logit_log(int[], vector)
+real categorical_logit_lpmf(int, vector)
+real categorical_logit_lpmf(int[], vector)
+int categorical_logit_rng(vector)
+real categorical_lpmf(int, vector)
+real categorical_lpmf(int[], vector)
+int categorical_rng(vector)
+real cauchy_ccdf_log(real, real, vector)
+real cauchy_ccdf_log(real, real, row_vector)
+real cauchy_ccdf_log(real, vector, real)
+real cauchy_ccdf_log(real, vector, vector)
+real cauchy_ccdf_log(real, vector, row_vector)
+real cauchy_ccdf_log(real, vector, real[])
+real cauchy_ccdf_log(real, row_vector, real)
+real cauchy_ccdf_log(real, row_vector, vector)
+real cauchy_ccdf_log(real, row_vector, row_vector)
+real cauchy_ccdf_log(real, row_vector, real[])
+real cauchy_ccdf_log(real, real[], vector)
+real cauchy_ccdf_log(real, real[], row_vector)
+real cauchy_ccdf_log(vector, real, real)
+real cauchy_ccdf_log(vector, real, vector)
+real cauchy_ccdf_log(vector, real, row_vector)
+real cauchy_ccdf_log(vector, real, real[])
+real cauchy_ccdf_log(vector, vector, real)
+real cauchy_ccdf_log(vector, vector, vector)
+real cauchy_ccdf_log(vector, vector, row_vector)
+real cauchy_ccdf_log(vector, vector, real[])
+real cauchy_ccdf_log(vector, row_vector, real)
+real cauchy_ccdf_log(vector, row_vector, vector)
+real cauchy_ccdf_log(vector, row_vector, row_vector)
+real cauchy_ccdf_log(vector, row_vector, real[])
+real cauchy_ccdf_log(vector, real[], real)
+real cauchy_ccdf_log(vector, real[], vector)
+real cauchy_ccdf_log(vector, real[], row_vector)
+real cauchy_ccdf_log(vector, real[], real[])
+real cauchy_ccdf_log(row_vector, real, real)
+real cauchy_ccdf_log(row_vector, real, vector)
+real cauchy_ccdf_log(row_vector, real, row_vector)
+real cauchy_ccdf_log(row_vector, real, real[])
+real cauchy_ccdf_log(row_vector, vector, real)
+real cauchy_ccdf_log(row_vector, vector, vector)
+real cauchy_ccdf_log(row_vector, vector, row_vector)
+real cauchy_ccdf_log(row_vector, vector, real[])
+real cauchy_ccdf_log(row_vector, row_vector, real)
+real cauchy_ccdf_log(row_vector, row_vector, vector)
+real cauchy_ccdf_log(row_vector, row_vector, row_vector)
+real cauchy_ccdf_log(row_vector, row_vector, real[])
+real cauchy_ccdf_log(row_vector, real[], real)
+real cauchy_ccdf_log(row_vector, real[], vector)
+real cauchy_ccdf_log(row_vector, real[], row_vector)
+real cauchy_ccdf_log(row_vector, real[], real[])
+real cauchy_ccdf_log(real[], real, vector)
+real cauchy_ccdf_log(real[], real, row_vector)
+real cauchy_ccdf_log(real[], real, real[])
+real cauchy_ccdf_log(real[], vector, real)
+real cauchy_ccdf_log(real[], vector, vector)
+real cauchy_ccdf_log(real[], vector, row_vector)
+real cauchy_ccdf_log(real[], vector, real[])
+real cauchy_ccdf_log(real[], row_vector, real)
+real cauchy_ccdf_log(real[], row_vector, vector)
+real cauchy_ccdf_log(real[], row_vector, row_vector)
+real cauchy_ccdf_log(real[], row_vector, real[])
+real cauchy_ccdf_log(real[], real[], vector)
+real cauchy_ccdf_log(real[], real[], row_vector)
+real cauchy_cdf(real, real, vector)
+real cauchy_cdf(real, real, row_vector)
+real cauchy_cdf(real, vector, real)
+real cauchy_cdf(real, vector, vector)
+real cauchy_cdf(real, vector, row_vector)
+real cauchy_cdf(real, vector, real[])
+real cauchy_cdf(real, row_vector, real)
+real cauchy_cdf(real, row_vector, vector)
+real cauchy_cdf(real, row_vector, row_vector)
+real cauchy_cdf(real, row_vector, real[])
+real cauchy_cdf(real, real[], vector)
+real cauchy_cdf(real, real[], row_vector)
+real cauchy_cdf(vector, real, real)
+real cauchy_cdf(vector, real, vector)
+real cauchy_cdf(vector, real, row_vector)
+real cauchy_cdf(vector, real, real[])
+real cauchy_cdf(vector, vector, real)
+real cauchy_cdf(vector, vector, vector)
+real cauchy_cdf(vector, vector, row_vector)
+real cauchy_cdf(vector, vector, real[])
+real cauchy_cdf(vector, row_vector, real)
+real cauchy_cdf(vector, row_vector, vector)
+real cauchy_cdf(vector, row_vector, row_vector)
+real cauchy_cdf(vector, row_vector, real[])
+real cauchy_cdf(vector, real[], real)
+real cauchy_cdf(vector, real[], vector)
+real cauchy_cdf(vector, real[], row_vector)
+real cauchy_cdf(vector, real[], real[])
+real cauchy_cdf(row_vector, real, real)
+real cauchy_cdf(row_vector, real, vector)
+real cauchy_cdf(row_vector, real, row_vector)
+real cauchy_cdf(row_vector, real, real[])
+real cauchy_cdf(row_vector, vector, real)
+real cauchy_cdf(row_vector, vector, vector)
+real cauchy_cdf(row_vector, vector, row_vector)
+real cauchy_cdf(row_vector, vector, real[])
+real cauchy_cdf(row_vector, row_vector, real)
+real cauchy_cdf(row_vector, row_vector, vector)
+real cauchy_cdf(row_vector, row_vector, row_vector)
+real cauchy_cdf(row_vector, row_vector, real[])
+real cauchy_cdf(row_vector, real[], real)
+real cauchy_cdf(row_vector, real[], vector)
+real cauchy_cdf(row_vector, real[], row_vector)
+real cauchy_cdf(row_vector, real[], real[])
+real cauchy_cdf(real[], real, vector)
+real cauchy_cdf(real[], real, row_vector)
+real cauchy_cdf(real[], vector, real)
+real cauchy_cdf(real[], vector, vector)
+real cauchy_cdf(real[], vector, row_vector)
+real cauchy_cdf(real[], vector, real[])
+real cauchy_cdf(real[], row_vector, real)
+real cauchy_cdf(real[], row_vector, vector)
+real cauchy_cdf(real[], row_vector, row_vector)
+real cauchy_cdf(real[], row_vector, real[])
+real cauchy_cdf(real[], real[], vector)
+real cauchy_cdf(real[], real[], row_vector)
+real cauchy_cdf_log(real, real, vector)
+real cauchy_cdf_log(real, real, row_vector)
+real cauchy_cdf_log(real, vector, real)
+real cauchy_cdf_log(real, vector, vector)
+real cauchy_cdf_log(real, vector, row_vector)
+real cauchy_cdf_log(real, vector, real[])
+real cauchy_cdf_log(real, row_vector, real)
+real cauchy_cdf_log(real, row_vector, vector)
+real cauchy_cdf_log(real, row_vector, row_vector)
+real cauchy_cdf_log(real, row_vector, real[])
+real cauchy_cdf_log(real, real[], vector)
+real cauchy_cdf_log(real, real[], row_vector)
+real cauchy_cdf_log(vector, real, real)
+real cauchy_cdf_log(vector, real, vector)
+real cauchy_cdf_log(vector, real, row_vector)
+real cauchy_cdf_log(vector, real, real[])
+real cauchy_cdf_log(vector, vector, real)
+real cauchy_cdf_log(vector, vector, vector)
+real cauchy_cdf_log(vector, vector, row_vector)
+real cauchy_cdf_log(vector, vector, real[])
+real cauchy_cdf_log(vector, row_vector, real)
+real cauchy_cdf_log(vector, row_vector, vector)
+real cauchy_cdf_log(vector, row_vector, row_vector)
+real cauchy_cdf_log(vector, row_vector, real[])
+real cauchy_cdf_log(vector, real[], real)
+real cauchy_cdf_log(vector, real[], vector)
+real cauchy_cdf_log(vector, real[], row_vector)
+real cauchy_cdf_log(vector, real[], real[])
+real cauchy_cdf_log(row_vector, real, real)
+real cauchy_cdf_log(row_vector, real, vector)
+real cauchy_cdf_log(row_vector, real, row_vector)
+real cauchy_cdf_log(row_vector, real, real[])
+real cauchy_cdf_log(row_vector, vector, real)
+real cauchy_cdf_log(row_vector, vector, vector)
+real cauchy_cdf_log(row_vector, vector, row_vector)
+real cauchy_cdf_log(row_vector, vector, real[])
+real cauchy_cdf_log(row_vector, row_vector, real)
+real cauchy_cdf_log(row_vector, row_vector, vector)
+real cauchy_cdf_log(row_vector, row_vector, row_vector)
+real cauchy_cdf_log(row_vector, row_vector, real[])
+real cauchy_cdf_log(row_vector, real[], real)
+real cauchy_cdf_log(row_vector, real[], vector)
+real cauchy_cdf_log(row_vector, real[], row_vector)
+real cauchy_cdf_log(row_vector, real[], real[])
+real cauchy_cdf_log(real[], real, vector)
+real cauchy_cdf_log(real[], real, row_vector)
+real cauchy_cdf_log(real[], vector, real)
+real cauchy_cdf_log(real[], vector, vector)
+real cauchy_cdf_log(real[], vector, row_vector)
+real cauchy_cdf_log(real[], vector, real[])
+real cauchy_cdf_log(real[], row_vector, real)
+real cauchy_cdf_log(real[], row_vector, vector)
+real cauchy_cdf_log(real[], row_vector, row_vector)
+real cauchy_cdf_log(real[], row_vector, real[])
+real cauchy_cdf_log(real[], real[], vector)
+real cauchy_cdf_log(real[], real[], row_vector)
+real cauchy_lccdf(real, real, vector)
+real cauchy_lccdf(real, real, row_vector)
+real cauchy_lccdf(real, vector, real)
+real cauchy_lccdf(real, vector, vector)
+real cauchy_lccdf(real, vector, row_vector)
+real cauchy_lccdf(real, vector, real[])
+real cauchy_lccdf(real, row_vector, real)
+real cauchy_lccdf(real, row_vector, vector)
+real cauchy_lccdf(real, row_vector, row_vector)
+real cauchy_lccdf(real, row_vector, real[])
+real cauchy_lccdf(real, real[], vector)
+real cauchy_lccdf(real, real[], row_vector)
+real cauchy_lccdf(vector, real, real)
+real cauchy_lccdf(vector, real, vector)
+real cauchy_lccdf(vector, real, row_vector)
+real cauchy_lccdf(vector, real, real[])
+real cauchy_lccdf(vector, vector, real)
+real cauchy_lccdf(vector, vector, vector)
+real cauchy_lccdf(vector, vector, row_vector)
+real cauchy_lccdf(vector, vector, real[])
+real cauchy_lccdf(vector, row_vector, real)
+real cauchy_lccdf(vector, row_vector, vector)
+real cauchy_lccdf(vector, row_vector, row_vector)
+real cauchy_lccdf(vector, row_vector, real[])
+real cauchy_lccdf(vector, real[], real)
+real cauchy_lccdf(vector, real[], vector)
+real cauchy_lccdf(vector, real[], row_vector)
+real cauchy_lccdf(vector, real[], real[])
+real cauchy_lccdf(row_vector, real, real)
+real cauchy_lccdf(row_vector, real, vector)
+real cauchy_lccdf(row_vector, real, row_vector)
+real cauchy_lccdf(row_vector, real, real[])
+real cauchy_lccdf(row_vector, vector, real)
+real cauchy_lccdf(row_vector, vector, vector)
+real cauchy_lccdf(row_vector, vector, row_vector)
+real cauchy_lccdf(row_vector, vector, real[])
+real cauchy_lccdf(row_vector, row_vector, real)
+real cauchy_lccdf(row_vector, row_vector, vector)
+real cauchy_lccdf(row_vector, row_vector, row_vector)
+real cauchy_lccdf(row_vector, row_vector, real[])
+real cauchy_lccdf(row_vector, real[], real)
+real cauchy_lccdf(row_vector, real[], vector)
+real cauchy_lccdf(row_vector, real[], row_vector)
+real cauchy_lccdf(row_vector, real[], real[])
+real cauchy_lccdf(real[], real, vector)
+real cauchy_lccdf(real[], real, row_vector)
+real cauchy_lccdf(real[], real, real[])
+real cauchy_lccdf(real[], vector, real)
+real cauchy_lccdf(real[], vector, vector)
+real cauchy_lccdf(real[], vector, row_vector)
+real cauchy_lccdf(real[], vector, real[])
+real cauchy_lccdf(real[], row_vector, real)
+real cauchy_lccdf(real[], row_vector, vector)
+real cauchy_lccdf(real[], row_vector, row_vector)
+real cauchy_lccdf(real[], row_vector, real[])
+real cauchy_lccdf(real[], real[], real)
+real cauchy_lccdf(real[], real[], vector)
+real cauchy_lccdf(real[], real[], row_vector)
+real cauchy_lcdf(real, real, vector)
+real cauchy_lcdf(real, real, row_vector)
+real cauchy_lcdf(real, vector, real)
+real cauchy_lcdf(real, vector, vector)
+real cauchy_lcdf(real, vector, row_vector)
+real cauchy_lcdf(real, vector, real[])
+real cauchy_lcdf(real, row_vector, real)
+real cauchy_lcdf(real, row_vector, vector)
+real cauchy_lcdf(real, row_vector, row_vector)
+real cauchy_lcdf(real, row_vector, real[])
+real cauchy_lcdf(real, real[], vector)
+real cauchy_lcdf(real, real[], row_vector)
+real cauchy_lcdf(vector, real, real)
+real cauchy_lcdf(vector, real, vector)
+real cauchy_lcdf(vector, real, row_vector)
+real cauchy_lcdf(vector, real, real[])
+real cauchy_lcdf(vector, vector, real)
+real cauchy_lcdf(vector, vector, vector)
+real cauchy_lcdf(vector, vector, row_vector)
+real cauchy_lcdf(vector, vector, real[])
+real cauchy_lcdf(vector, row_vector, real)
+real cauchy_lcdf(vector, row_vector, vector)
+real cauchy_lcdf(vector, row_vector, row_vector)
+real cauchy_lcdf(vector, row_vector, real[])
+real cauchy_lcdf(vector, real[], real)
+real cauchy_lcdf(vector, real[], vector)
+real cauchy_lcdf(vector, real[], row_vector)
+real cauchy_lcdf(vector, real[], real[])
+real cauchy_lcdf(row_vector, real, real)
+real cauchy_lcdf(row_vector, real, vector)
+real cauchy_lcdf(row_vector, real, row_vector)
+real cauchy_lcdf(row_vector, real, real[])
+real cauchy_lcdf(row_vector, vector, real)
+real cauchy_lcdf(row_vector, vector, vector)
+real cauchy_lcdf(row_vector, vector, row_vector)
+real cauchy_lcdf(row_vector, vector, real[])
+real cauchy_lcdf(row_vector, row_vector, real)
+real cauchy_lcdf(row_vector, row_vector, vector)
+real cauchy_lcdf(row_vector, row_vector, row_vector)
+real cauchy_lcdf(row_vector, row_vector, real[])
+real cauchy_lcdf(row_vector, real[], real)
+real cauchy_lcdf(row_vector, real[], vector)
+real cauchy_lcdf(row_vector, real[], row_vector)
+real cauchy_lcdf(row_vector, real[], real[])
+real cauchy_lcdf(real[], real, vector)
+real cauchy_lcdf(real[], real, row_vector)
+real cauchy_lcdf(real[], vector, real)
+real cauchy_lcdf(real[], vector, vector)
+real cauchy_lcdf(real[], vector, row_vector)
+real cauchy_lcdf(real[], vector, real[])
+real cauchy_lcdf(real[], row_vector, real)
+real cauchy_lcdf(real[], row_vector, vector)
+real cauchy_lcdf(real[], row_vector, row_vector)
+real cauchy_lcdf(real[], row_vector, real[])
+real cauchy_lcdf(real[], real[], vector)
+real cauchy_lcdf(real[], real[], row_vector)
+real cauchy_log(real, real, vector)
+real cauchy_log(real, real, row_vector)
+real cauchy_log(real, vector, real)
+real cauchy_log(real, vector, vector)
+real cauchy_log(real, vector, row_vector)
+real cauchy_log(real, vector, real[])
+real cauchy_log(real, row_vector, real)
+real cauchy_log(real, row_vector, vector)
+real cauchy_log(real, row_vector, row_vector)
+real cauchy_log(real, row_vector, real[])
+real cauchy_log(real, real[], vector)
+real cauchy_log(real, real[], row_vector)
+real cauchy_log(vector, real, real)
+real cauchy_log(vector, real, vector)
+real cauchy_log(vector, real, row_vector)
+real cauchy_log(vector, real, real[])
+real cauchy_log(vector, vector, real)
+real cauchy_log(vector, vector, vector)
+real cauchy_log(vector, vector, row_vector)
+real cauchy_log(vector, vector, real[])
+real cauchy_log(vector, row_vector, real)
+real cauchy_log(vector, row_vector, vector)
+real cauchy_log(vector, row_vector, row_vector)
+real cauchy_log(vector, row_vector, real[])
+real cauchy_log(vector, real[], real)
+real cauchy_log(vector, real[], vector)
+real cauchy_log(vector, real[], row_vector)
+real cauchy_log(vector, real[], real[])
+real cauchy_log(row_vector, real, real)
+real cauchy_log(row_vector, real, vector)
+real cauchy_log(row_vector, real, row_vector)
+real cauchy_log(row_vector, real, real[])
+real cauchy_log(row_vector, vector, real)
+real cauchy_log(row_vector, vector, vector)
+real cauchy_log(row_vector, vector, row_vector)
+real cauchy_log(row_vector, vector, real[])
+real cauchy_log(row_vector, row_vector, real)
+real cauchy_log(row_vector, row_vector, vector)
+real cauchy_log(row_vector, row_vector, row_vector)
+real cauchy_log(row_vector, row_vector, real[])
+real cauchy_log(row_vector, real[], real)
+real cauchy_log(row_vector, real[], vector)
+real cauchy_log(row_vector, real[], row_vector)
+real cauchy_log(row_vector, real[], real[])
+real cauchy_log(real[], real, vector)
+real cauchy_log(real[], real, row_vector)
+real cauchy_log(real[], real, real[])
+real cauchy_log(real[], vector, real)
+real cauchy_log(real[], vector, vector)
+real cauchy_log(real[], vector, row_vector)
+real cauchy_log(real[], vector, real[])
+real cauchy_log(real[], row_vector, real)
+real cauchy_log(real[], row_vector, vector)
+real cauchy_log(real[], row_vector, row_vector)
+real cauchy_log(real[], row_vector, real[])
+real cauchy_log(real[], real[], vector)
+real cauchy_log(real[], real[], row_vector)
+real cauchy_lpdf(real, real, vector)
+real cauchy_lpdf(real, real, row_vector)
+real cauchy_lpdf(real, vector, real)
+real cauchy_lpdf(real, vector, vector)
+real cauchy_lpdf(real, vector, row_vector)
+real cauchy_lpdf(real, vector, real[])
+real cauchy_lpdf(real, row_vector, real)
+real cauchy_lpdf(real, row_vector, vector)
+real cauchy_lpdf(real, row_vector, row_vector)
+real cauchy_lpdf(real, row_vector, real[])
+real cauchy_lpdf(real, real[], vector)
+real cauchy_lpdf(real, real[], row_vector)
+real cauchy_lpdf(vector, real, real)
+real cauchy_lpdf(vector, real, vector)
+real cauchy_lpdf(vector, real, row_vector)
+real cauchy_lpdf(vector, real, real[])
+real cauchy_lpdf(vector, vector, real)
+real cauchy_lpdf(vector, vector, vector)
+real cauchy_lpdf(vector, vector, row_vector)
+real cauchy_lpdf(vector, vector, real[])
+real cauchy_lpdf(vector, row_vector, real)
+real cauchy_lpdf(vector, row_vector, vector)
+real cauchy_lpdf(vector, row_vector, row_vector)
+real cauchy_lpdf(vector, row_vector, real[])
+real cauchy_lpdf(vector, real[], real)
+real cauchy_lpdf(vector, real[], vector)
+real cauchy_lpdf(vector, real[], row_vector)
+real cauchy_lpdf(vector, real[], real[])
+real cauchy_lpdf(row_vector, real, real)
+real cauchy_lpdf(row_vector, real, vector)
+real cauchy_lpdf(row_vector, real, row_vector)
+real cauchy_lpdf(row_vector, real, real[])
+real cauchy_lpdf(row_vector, vector, real)
+real cauchy_lpdf(row_vector, vector, vector)
+real cauchy_lpdf(row_vector, vector, row_vector)
+real cauchy_lpdf(row_vector, vector, real[])
+real cauchy_lpdf(row_vector, row_vector, real)
+real cauchy_lpdf(row_vector, row_vector, vector)
+real cauchy_lpdf(row_vector, row_vector, row_vector)
+real cauchy_lpdf(row_vector, row_vector, real[])
+real cauchy_lpdf(row_vector, real[], real)
+real cauchy_lpdf(row_vector, real[], vector)
+real cauchy_lpdf(row_vector, real[], row_vector)
+real cauchy_lpdf(row_vector, real[], real[])
+real cauchy_lpdf(real[], real, vector)
+real cauchy_lpdf(real[], real, row_vector)
+real cauchy_lpdf(real[], real, real[])
+real cauchy_lpdf(real[], vector, real)
+real cauchy_lpdf(real[], vector, vector)
+real cauchy_lpdf(real[], vector, row_vector)
+real cauchy_lpdf(real[], vector, real[])
+real cauchy_lpdf(real[], row_vector, real)
+real cauchy_lpdf(real[], row_vector, vector)
+real cauchy_lpdf(real[], row_vector, row_vector)
+real cauchy_lpdf(real[], row_vector, real[])
+real cauchy_lpdf(real[], real[], vector)
+real cauchy_lpdf(real[], real[], row_vector)
+real[] cauchy_rng(int, vector)
+real[] cauchy_rng(int, row_vector)
+real[] cauchy_rng(real, vector)
+real[] cauchy_rng(real, row_vector)
+real[] cauchy_rng(vector, int)
+real[] cauchy_rng(vector, real)
+real[] cauchy_rng(vector, vector)
+real[] cauchy_rng(vector, row_vector)
+real[] cauchy_rng(vector, int[])
+real[] cauchy_rng(vector, real[])
+real[] cauchy_rng(row_vector, int)
+real[] cauchy_rng(row_vector, real)
+real[] cauchy_rng(row_vector, vector)
+real[] cauchy_rng(row_vector, row_vector)
+real[] cauchy_rng(row_vector, int[])
+real[] cauchy_rng(row_vector, real[])
+real[] cauchy_rng(int[], vector)
+real[] cauchy_rng(int[], row_vector)
+real[] cauchy_rng(real[], vector)
+real[] cauchy_rng(real[], row_vector)
+real chi_square_ccdf_log(real, vector)
+real chi_square_ccdf_log(real, row_vector)
+real chi_square_ccdf_log(vector, real)
+real chi_square_ccdf_log(vector, vector)
+real chi_square_ccdf_log(vector, row_vector)
+real chi_square_ccdf_log(vector, real[])
+real chi_square_ccdf_log(row_vector, real)
+real chi_square_ccdf_log(row_vector, vector)
+real chi_square_ccdf_log(row_vector, row_vector)
+real chi_square_ccdf_log(row_vector, real[])
+real chi_square_ccdf_log(real[], vector)
+real chi_square_ccdf_log(real[], row_vector)
+real chi_square_cdf(real, vector)
+real chi_square_cdf(real, row_vector)
+real chi_square_cdf(vector, real)
+real chi_square_cdf(vector, vector)
+real chi_square_cdf(vector, row_vector)
+real chi_square_cdf(vector, real[])
+real chi_square_cdf(row_vector, real)
+real chi_square_cdf(row_vector, vector)
+real chi_square_cdf(row_vector, row_vector)
+real chi_square_cdf(row_vector, real[])
+real chi_square_cdf(real[], vector)
+real chi_square_cdf(real[], row_vector)
+real chi_square_cdf_log(real, vector)
+real chi_square_cdf_log(real, row_vector)
+real chi_square_cdf_log(vector, real)
+real chi_square_cdf_log(vector, vector)
+real chi_square_cdf_log(vector, row_vector)
+real chi_square_cdf_log(vector, real[])
+real chi_square_cdf_log(row_vector, real)
+real chi_square_cdf_log(row_vector, vector)
+real chi_square_cdf_log(row_vector, row_vector)
+real chi_square_cdf_log(row_vector, real[])
+real chi_square_cdf_log(real[], vector)
+real chi_square_cdf_log(real[], row_vector)
+real chi_square_lccdf(real, vector)
+real chi_square_lccdf(real, row_vector)
+real chi_square_lccdf(vector, real)
+real chi_square_lccdf(vector, vector)
+real chi_square_lccdf(vector, row_vector)
+real chi_square_lccdf(vector, real[])
+real chi_square_lccdf(row_vector, real)
+real chi_square_lccdf(row_vector, vector)
+real chi_square_lccdf(row_vector, row_vector)
+real chi_square_lccdf(row_vector, real[])
+real chi_square_lccdf(real[], vector)
+real chi_square_lccdf(real[], row_vector)
+real chi_square_lcdf(real, vector)
+real chi_square_lcdf(real, row_vector)
+real chi_square_lcdf(vector, real)
+real chi_square_lcdf(vector, vector)
+real chi_square_lcdf(vector, row_vector)
+real chi_square_lcdf(vector, real[])
+real chi_square_lcdf(row_vector, real)
+real chi_square_lcdf(row_vector, vector)
+real chi_square_lcdf(row_vector, row_vector)
+real chi_square_lcdf(row_vector, real[])
+real chi_square_lcdf(real[], vector)
+real chi_square_lcdf(real[], row_vector)
+real chi_square_log(real, vector)
+real chi_square_log(real, row_vector)
+real chi_square_log(vector, real)
+real chi_square_log(vector, vector)
+real chi_square_log(vector, row_vector)
+real chi_square_log(vector, real[])
+real chi_square_log(row_vector, real)
+real chi_square_log(row_vector, vector)
+real chi_square_log(row_vector, row_vector)
+real chi_square_log(row_vector, real[])
+real chi_square_log(real[], vector)
+real chi_square_log(real[], row_vector)
+real chi_square_lpdf(real, vector)
+real chi_square_lpdf(real, row_vector)
+real chi_square_lpdf(vector, real)
+real chi_square_lpdf(vector, vector)
+real chi_square_lpdf(vector, row_vector)
+real chi_square_lpdf(vector, real[])
+real chi_square_lpdf(row_vector, real)
+real chi_square_lpdf(row_vector, vector)
+real chi_square_lpdf(row_vector, row_vector)
+real chi_square_lpdf(row_vector, real[])
+real chi_square_lpdf(real[], vector)
+real chi_square_lpdf(real[], row_vector)
+real[] chi_square_rng(vector)
+real[] chi_square_rng(row_vector)
+row_vector columns_dot_product(vector, vector)
+row_vector columns_dot_product(row_vector, row_vector)
+row_vector columns_dot_product(matrix, matrix)
+row_vector columns_dot_self(vector)
+row_vector columns_dot_self(row_vector)
+row_vector columns_dot_self(matrix)
+int[] csr_extract_u(matrix)
+int[] csr_extract_v(matrix)
+vector csr_extract_w(matrix)
+vector csr_matrix_times_vector(int, int, vector, int[], int[], vector)
+matrix csr_to_dense_matrix(int, int, vector, int[], int[])
+real dirichlet_log(vector, vector)
+real dirichlet_log(vector, row_vector)
+real dirichlet_log(vector, vector[])
+real dirichlet_log(vector, row_vector[])
+real dirichlet_log(row_vector, vector)
+real dirichlet_log(row_vector, row_vector)
+real dirichlet_log(row_vector, vector[])
+real dirichlet_log(row_vector, row_vector[])
+real dirichlet_log(vector[], vector)
+real dirichlet_log(vector[], row_vector)
+real dirichlet_log(vector[], vector[])
+real dirichlet_log(vector[], row_vector[])
+real dirichlet_log(row_vector[], vector)
+real dirichlet_log(row_vector[], row_vector)
+real dirichlet_log(row_vector[], vector[])
+real dirichlet_log(row_vector[], row_vector[])
+real dirichlet_lpdf(vector, vector)
+real dirichlet_lpdf(vector, row_vector)
+real dirichlet_lpdf(vector, vector[])
+real dirichlet_lpdf(vector, row_vector[])
+real dirichlet_lpdf(row_vector, vector)
+real dirichlet_lpdf(row_vector, row_vector)
+real dirichlet_lpdf(row_vector, vector[])
+real dirichlet_lpdf(row_vector, row_vector[])
+real dirichlet_lpdf(vector[], vector)
+real dirichlet_lpdf(vector[], row_vector)
+real dirichlet_lpdf(vector[], vector[])
+real dirichlet_lpdf(vector[], row_vector[])
+real dirichlet_lpdf(row_vector[], vector)
+real dirichlet_lpdf(row_vector[], row_vector)
+real dirichlet_lpdf(row_vector[], vector[])
+real dirichlet_lpdf(row_vector[], row_vector[])
+vector dirichlet_rng(vector)
+real distance(vector, vector)
+real distance(vector, row_vector)
+real distance(row_vector, vector)
+real distance(row_vector, row_vector)
+real dot_product(vector, vector)
+real dot_product(vector, row_vector)
+real dot_product(row_vector, vector)
+real dot_product(row_vector, row_vector)
+real dot_product(real[], real[])
+real double_exponential_ccdf_log(real, real, vector)
+real double_exponential_ccdf_log(real, real, row_vector)
+real double_exponential_ccdf_log(real, vector, real)
+real double_exponential_ccdf_log(real, vector, vector)
+real double_exponential_ccdf_log(real, vector, row_vector)
+real double_exponential_ccdf_log(real, vector, real[])
+real double_exponential_ccdf_log(real, row_vector, real)
+real double_exponential_ccdf_log(real, row_vector, vector)
+real double_exponential_ccdf_log(real, row_vector, row_vector)
+real double_exponential_ccdf_log(real, row_vector, real[])
+real double_exponential_ccdf_log(real, real[], vector)
+real double_exponential_ccdf_log(real, real[], row_vector)
+real double_exponential_ccdf_log(vector, real, real)
+real double_exponential_ccdf_log(vector, real, vector)
+real double_exponential_ccdf_log(vector, real, row_vector)
+real double_exponential_ccdf_log(vector, real, real[])
+real double_exponential_ccdf_log(vector, vector, real)
+real double_exponential_ccdf_log(vector, vector, vector)
+real double_exponential_ccdf_log(vector, vector, row_vector)
+real double_exponential_ccdf_log(vector, vector, real[])
+real double_exponential_ccdf_log(vector, row_vector, real)
+real double_exponential_ccdf_log(vector, row_vector, vector)
+real double_exponential_ccdf_log(vector, row_vector, row_vector)
+real double_exponential_ccdf_log(vector, row_vector, real[])
+real double_exponential_ccdf_log(vector, real[], real)
+real double_exponential_ccdf_log(vector, real[], vector)
+real double_exponential_ccdf_log(vector, real[], row_vector)
+real double_exponential_ccdf_log(vector, real[], real[])
+real double_exponential_ccdf_log(row_vector, real, real)
+real double_exponential_ccdf_log(row_vector, real, vector)
+real double_exponential_ccdf_log(row_vector, real, row_vector)
+real double_exponential_ccdf_log(row_vector, real, real[])
+real double_exponential_ccdf_log(row_vector, vector, real)
+real double_exponential_ccdf_log(row_vector, vector, vector)
+real double_exponential_ccdf_log(row_vector, vector, row_vector)
+real double_exponential_ccdf_log(row_vector, vector, real[])
+real double_exponential_ccdf_log(row_vector, row_vector, real)
+real double_exponential_ccdf_log(row_vector, row_vector, vector)
+real double_exponential_ccdf_log(row_vector, row_vector, row_vector)
+real double_exponential_ccdf_log(row_vector, row_vector, real[])
+real double_exponential_ccdf_log(row_vector, real[], real)
+real double_exponential_ccdf_log(row_vector, real[], vector)
+real double_exponential_ccdf_log(row_vector, real[], row_vector)
+real double_exponential_ccdf_log(row_vector, real[], real[])
+real double_exponential_ccdf_log(real[], real, vector)
+real double_exponential_ccdf_log(real[], real, row_vector)
+real double_exponential_ccdf_log(real[], vector, real)
+real double_exponential_ccdf_log(real[], vector, vector)
+real double_exponential_ccdf_log(real[], vector, row_vector)
+real double_exponential_ccdf_log(real[], vector, real[])
+real double_exponential_ccdf_log(real[], row_vector, real)
+real double_exponential_ccdf_log(real[], row_vector, vector)
+real double_exponential_ccdf_log(real[], row_vector, row_vector)
+real double_exponential_ccdf_log(real[], row_vector, real[])
+real double_exponential_ccdf_log(real[], real[], vector)
+real double_exponential_ccdf_log(real[], real[], row_vector)
+real double_exponential_cdf(real, real, vector)
+real double_exponential_cdf(real, real, row_vector)
+real double_exponential_cdf(real, vector, real)
+real double_exponential_cdf(real, vector, vector)
+real double_exponential_cdf(real, vector, row_vector)
+real double_exponential_cdf(real, vector, real[])
+real double_exponential_cdf(real, row_vector, real)
+real double_exponential_cdf(real, row_vector, vector)
+real double_exponential_cdf(real, row_vector, row_vector)
+real double_exponential_cdf(real, row_vector, real[])
+real double_exponential_cdf(real, real[], vector)
+real double_exponential_cdf(real, real[], row_vector)
+real double_exponential_cdf(vector, real, real)
+real double_exponential_cdf(vector, real, vector)
+real double_exponential_cdf(vector, real, row_vector)
+real double_exponential_cdf(vector, real, real[])
+real double_exponential_cdf(vector, vector, real)
+real double_exponential_cdf(vector, vector, vector)
+real double_exponential_cdf(vector, vector, row_vector)
+real double_exponential_cdf(vector, vector, real[])
+real double_exponential_cdf(vector, row_vector, real)
+real double_exponential_cdf(vector, row_vector, vector)
+real double_exponential_cdf(vector, row_vector, row_vector)
+real double_exponential_cdf(vector, row_vector, real[])
+real double_exponential_cdf(vector, real[], real)
+real double_exponential_cdf(vector, real[], vector)
+real double_exponential_cdf(vector, real[], row_vector)
+real double_exponential_cdf(vector, real[], real[])
+real double_exponential_cdf(row_vector, real, real)
+real double_exponential_cdf(row_vector, real, vector)
+real double_exponential_cdf(row_vector, real, row_vector)
+real double_exponential_cdf(row_vector, real, real[])
+real double_exponential_cdf(row_vector, vector, real)
+real double_exponential_cdf(row_vector, vector, vector)
+real double_exponential_cdf(row_vector, vector, row_vector)
+real double_exponential_cdf(row_vector, vector, real[])
+real double_exponential_cdf(row_vector, row_vector, real)
+real double_exponential_cdf(row_vector, row_vector, vector)
+real double_exponential_cdf(row_vector, row_vector, row_vector)
+real double_exponential_cdf(row_vector, row_vector, real[])
+real double_exponential_cdf(row_vector, real[], real)
+real double_exponential_cdf(row_vector, real[], vector)
+real double_exponential_cdf(row_vector, real[], row_vector)
+real double_exponential_cdf(row_vector, real[], real[])
+real double_exponential_cdf(real[], real, vector)
+real double_exponential_cdf(real[], real, row_vector)
+real double_exponential_cdf(real[], vector, real)
+real double_exponential_cdf(real[], vector, vector)
+real double_exponential_cdf(real[], vector, row_vector)
+real double_exponential_cdf(real[], vector, real[])
+real double_exponential_cdf(real[], row_vector, real)
+real double_exponential_cdf(real[], row_vector, vector)
+real double_exponential_cdf(real[], row_vector, row_vector)
+real double_exponential_cdf(real[], row_vector, real[])
+real double_exponential_cdf(real[], real[], vector)
+real double_exponential_cdf(real[], real[], row_vector)
+real double_exponential_cdf_log(real, real, vector)
+real double_exponential_cdf_log(real, real, row_vector)
+real double_exponential_cdf_log(real, vector, real)
+real double_exponential_cdf_log(real, vector, vector)
+real double_exponential_cdf_log(real, vector, row_vector)
+real double_exponential_cdf_log(real, vector, real[])
+real double_exponential_cdf_log(real, row_vector, real)
+real double_exponential_cdf_log(real, row_vector, vector)
+real double_exponential_cdf_log(real, row_vector, row_vector)
+real double_exponential_cdf_log(real, row_vector, real[])
+real double_exponential_cdf_log(real, real[], vector)
+real double_exponential_cdf_log(real, real[], row_vector)
+real double_exponential_cdf_log(vector, real, real)
+real double_exponential_cdf_log(vector, real, vector)
+real double_exponential_cdf_log(vector, real, row_vector)
+real double_exponential_cdf_log(vector, real, real[])
+real double_exponential_cdf_log(vector, vector, real)
+real double_exponential_cdf_log(vector, vector, vector)
+real double_exponential_cdf_log(vector, vector, row_vector)
+real double_exponential_cdf_log(vector, vector, real[])
+real double_exponential_cdf_log(vector, row_vector, real)
+real double_exponential_cdf_log(vector, row_vector, vector)
+real double_exponential_cdf_log(vector, row_vector, row_vector)
+real double_exponential_cdf_log(vector, row_vector, real[])
+real double_exponential_cdf_log(vector, real[], real)
+real double_exponential_cdf_log(vector, real[], vector)
+real double_exponential_cdf_log(vector, real[], row_vector)
+real double_exponential_cdf_log(vector, real[], real[])
+real double_exponential_cdf_log(row_vector, real, real)
+real double_exponential_cdf_log(row_vector, real, vector)
+real double_exponential_cdf_log(row_vector, real, row_vector)
+real double_exponential_cdf_log(row_vector, real, real[])
+real double_exponential_cdf_log(row_vector, vector, real)
+real double_exponential_cdf_log(row_vector, vector, vector)
+real double_exponential_cdf_log(row_vector, vector, row_vector)
+real double_exponential_cdf_log(row_vector, vector, real[])
+real double_exponential_cdf_log(row_vector, row_vector, real)
+real double_exponential_cdf_log(row_vector, row_vector, vector)
+real double_exponential_cdf_log(row_vector, row_vector, row_vector)
+real double_exponential_cdf_log(row_vector, row_vector, real[])
+real double_exponential_cdf_log(row_vector, real[], real)
+real double_exponential_cdf_log(row_vector, real[], vector)
+real double_exponential_cdf_log(row_vector, real[], row_vector)
+real double_exponential_cdf_log(row_vector, real[], real[])
+real double_exponential_cdf_log(real[], real, vector)
+real double_exponential_cdf_log(real[], real, row_vector)
+real double_exponential_cdf_log(real[], vector, real)
+real double_exponential_cdf_log(real[], vector, vector)
+real double_exponential_cdf_log(real[], vector, row_vector)
+real double_exponential_cdf_log(real[], vector, real[])
+real double_exponential_cdf_log(real[], row_vector, real)
+real double_exponential_cdf_log(real[], row_vector, vector)
+real double_exponential_cdf_log(real[], row_vector, row_vector)
+real double_exponential_cdf_log(real[], row_vector, real[])
+real double_exponential_cdf_log(real[], real[], vector)
+real double_exponential_cdf_log(real[], real[], row_vector)
+real double_exponential_lccdf(real, real, vector)
+real double_exponential_lccdf(real, real, row_vector)
+real double_exponential_lccdf(real, vector, real)
+real double_exponential_lccdf(real, vector, vector)
+real double_exponential_lccdf(real, vector, row_vector)
+real double_exponential_lccdf(real, vector, real[])
+real double_exponential_lccdf(real, row_vector, real)
+real double_exponential_lccdf(real, row_vector, vector)
+real double_exponential_lccdf(real, row_vector, row_vector)
+real double_exponential_lccdf(real, row_vector, real[])
+real double_exponential_lccdf(real, real[], vector)
+real double_exponential_lccdf(real, real[], row_vector)
+real double_exponential_lccdf(vector, real, real)
+real double_exponential_lccdf(vector, real, vector)
+real double_exponential_lccdf(vector, real, row_vector)
+real double_exponential_lccdf(vector, real, real[])
+real double_exponential_lccdf(vector, vector, real)
+real double_exponential_lccdf(vector, vector, vector)
+real double_exponential_lccdf(vector, vector, row_vector)
+real double_exponential_lccdf(vector, vector, real[])
+real double_exponential_lccdf(vector, row_vector, real)
+real double_exponential_lccdf(vector, row_vector, vector)
+real double_exponential_lccdf(vector, row_vector, row_vector)
+real double_exponential_lccdf(vector, row_vector, real[])
+real double_exponential_lccdf(vector, real[], real)
+real double_exponential_lccdf(vector, real[], vector)
+real double_exponential_lccdf(vector, real[], row_vector)
+real double_exponential_lccdf(vector, real[], real[])
+real double_exponential_lccdf(row_vector, real, real)
+real double_exponential_lccdf(row_vector, real, vector)
+real double_exponential_lccdf(row_vector, real, row_vector)
+real double_exponential_lccdf(row_vector, real, real[])
+real double_exponential_lccdf(row_vector, vector, real)
+real double_exponential_lccdf(row_vector, vector, vector)
+real double_exponential_lccdf(row_vector, vector, row_vector)
+real double_exponential_lccdf(row_vector, vector, real[])
+real double_exponential_lccdf(row_vector, row_vector, real)
+real double_exponential_lccdf(row_vector, row_vector, vector)
+real double_exponential_lccdf(row_vector, row_vector, row_vector)
+real double_exponential_lccdf(row_vector, row_vector, real[])
+real double_exponential_lccdf(row_vector, real[], real)
+real double_exponential_lccdf(row_vector, real[], vector)
+real double_exponential_lccdf(row_vector, real[], row_vector)
+real double_exponential_lccdf(row_vector, real[], real[])
+real double_exponential_lccdf(real[], real, vector)
+real double_exponential_lccdf(real[], real, row_vector)
+real double_exponential_lccdf(real[], vector, real)
+real double_exponential_lccdf(real[], vector, vector)
+real double_exponential_lccdf(real[], vector, row_vector)
+real double_exponential_lccdf(real[], vector, real[])
+real double_exponential_lccdf(real[], row_vector, real)
+real double_exponential_lccdf(real[], row_vector, vector)
+real double_exponential_lccdf(real[], row_vector, row_vector)
+real double_exponential_lccdf(real[], row_vector, real[])
+real double_exponential_lccdf(real[], real[], vector)
+real double_exponential_lccdf(real[], real[], row_vector)
+real double_exponential_lcdf(real, real, vector)
+real double_exponential_lcdf(real, real, row_vector)
+real double_exponential_lcdf(real, vector, real)
+real double_exponential_lcdf(real, vector, vector)
+real double_exponential_lcdf(real, vector, row_vector)
+real double_exponential_lcdf(real, vector, real[])
+real double_exponential_lcdf(real, row_vector, real)
+real double_exponential_lcdf(real, row_vector, vector)
+real double_exponential_lcdf(real, row_vector, row_vector)
+real double_exponential_lcdf(real, row_vector, real[])
+real double_exponential_lcdf(real, real[], vector)
+real double_exponential_lcdf(real, real[], row_vector)
+real double_exponential_lcdf(vector, real, real)
+real double_exponential_lcdf(vector, real, vector)
+real double_exponential_lcdf(vector, real, row_vector)
+real double_exponential_lcdf(vector, real, real[])
+real double_exponential_lcdf(vector, vector, real)
+real double_exponential_lcdf(vector, vector, vector)
+real double_exponential_lcdf(vector, vector, row_vector)
+real double_exponential_lcdf(vector, vector, real[])
+real double_exponential_lcdf(vector, row_vector, real)
+real double_exponential_lcdf(vector, row_vector, vector)
+real double_exponential_lcdf(vector, row_vector, row_vector)
+real double_exponential_lcdf(vector, row_vector, real[])
+real double_exponential_lcdf(vector, real[], real)
+real double_exponential_lcdf(vector, real[], vector)
+real double_exponential_lcdf(vector, real[], row_vector)
+real double_exponential_lcdf(vector, real[], real[])
+real double_exponential_lcdf(row_vector, real, real)
+real double_exponential_lcdf(row_vector, real, vector)
+real double_exponential_lcdf(row_vector, real, row_vector)
+real double_exponential_lcdf(row_vector, real, real[])
+real double_exponential_lcdf(row_vector, vector, real)
+real double_exponential_lcdf(row_vector, vector, vector)
+real double_exponential_lcdf(row_vector, vector, row_vector)
+real double_exponential_lcdf(row_vector, vector, real[])
+real double_exponential_lcdf(row_vector, row_vector, real)
+real double_exponential_lcdf(row_vector, row_vector, vector)
+real double_exponential_lcdf(row_vector, row_vector, row_vector)
+real double_exponential_lcdf(row_vector, row_vector, real[])
+real double_exponential_lcdf(row_vector, real[], real)
+real double_exponential_lcdf(row_vector, real[], vector)
+real double_exponential_lcdf(row_vector, real[], row_vector)
+real double_exponential_lcdf(row_vector, real[], real[])
+real double_exponential_lcdf(real[], real, vector)
+real double_exponential_lcdf(real[], real, row_vector)
+real double_exponential_lcdf(real[], vector, real)
+real double_exponential_lcdf(real[], vector, vector)
+real double_exponential_lcdf(real[], vector, row_vector)
+real double_exponential_lcdf(real[], vector, real[])
+real double_exponential_lcdf(real[], row_vector, real)
+real double_exponential_lcdf(real[], row_vector, vector)
+real double_exponential_lcdf(real[], row_vector, row_vector)
+real double_exponential_lcdf(real[], row_vector, real[])
+real double_exponential_lcdf(real[], real[], vector)
+real double_exponential_lcdf(real[], real[], row_vector)
+real double_exponential_log(real, real, vector)
+real double_exponential_log(real, real, row_vector)
+real double_exponential_log(real, vector, real)
+real double_exponential_log(real, vector, vector)
+real double_exponential_log(real, vector, row_vector)
+real double_exponential_log(real, vector, real[])
+real double_exponential_log(real, row_vector, real)
+real double_exponential_log(real, row_vector, vector)
+real double_exponential_log(real, row_vector, row_vector)
+real double_exponential_log(real, row_vector, real[])
+real double_exponential_log(real, real[], vector)
+real double_exponential_log(real, real[], row_vector)
+real double_exponential_log(vector, real, real)
+real double_exponential_log(vector, real, vector)
+real double_exponential_log(vector, real, row_vector)
+real double_exponential_log(vector, real, real[])
+real double_exponential_log(vector, vector, real)
+real double_exponential_log(vector, vector, vector)
+real double_exponential_log(vector, vector, row_vector)
+real double_exponential_log(vector, vector, real[])
+real double_exponential_log(vector, row_vector, real)
+real double_exponential_log(vector, row_vector, vector)
+real double_exponential_log(vector, row_vector, row_vector)
+real double_exponential_log(vector, row_vector, real[])
+real double_exponential_log(vector, real[], real)
+real double_exponential_log(vector, real[], vector)
+real double_exponential_log(vector, real[], row_vector)
+real double_exponential_log(vector, real[], real[])
+real double_exponential_log(row_vector, real, real)
+real double_exponential_log(row_vector, real, vector)
+real double_exponential_log(row_vector, real, row_vector)
+real double_exponential_log(row_vector, real, real[])
+real double_exponential_log(row_vector, vector, real)
+real double_exponential_log(row_vector, vector, vector)
+real double_exponential_log(row_vector, vector, row_vector)
+real double_exponential_log(row_vector, vector, real[])
+real double_exponential_log(row_vector, row_vector, real)
+real double_exponential_log(row_vector, row_vector, vector)
+real double_exponential_log(row_vector, row_vector, row_vector)
+real double_exponential_log(row_vector, row_vector, real[])
+real double_exponential_log(row_vector, real[], real)
+real double_exponential_log(row_vector, real[], vector)
+real double_exponential_log(row_vector, real[], row_vector)
+real double_exponential_log(row_vector, real[], real[])
+real double_exponential_log(real[], real, vector)
+real double_exponential_log(real[], real, row_vector)
+real double_exponential_log(real[], real, real[])
+real double_exponential_log(real[], vector, real)
+real double_exponential_log(real[], vector, vector)
+real double_exponential_log(real[], vector, row_vector)
+real double_exponential_log(real[], vector, real[])
+real double_exponential_log(real[], row_vector, real)
+real double_exponential_log(real[], row_vector, vector)
+real double_exponential_log(real[], row_vector, row_vector)
+real double_exponential_log(real[], row_vector, real[])
+real double_exponential_log(real[], real[], vector)
+real double_exponential_log(real[], real[], row_vector)
+real double_exponential_lpdf(real, real, vector)
+real double_exponential_lpdf(real, real, row_vector)
+real double_exponential_lpdf(real, vector, real)
+real double_exponential_lpdf(real, vector, vector)
+real double_exponential_lpdf(real, vector, row_vector)
+real double_exponential_lpdf(real, vector, real[])
+real double_exponential_lpdf(real, row_vector, real)
+real double_exponential_lpdf(real, row_vector, vector)
+real double_exponential_lpdf(real, row_vector, row_vector)
+real double_exponential_lpdf(real, row_vector, real[])
+real double_exponential_lpdf(real, real[], vector)
+real double_exponential_lpdf(real, real[], row_vector)
+real double_exponential_lpdf(vector, real, real)
+real double_exponential_lpdf(vector, real, vector)
+real double_exponential_lpdf(vector, real, row_vector)
+real double_exponential_lpdf(vector, real, real[])
+real double_exponential_lpdf(vector, vector, real)
+real double_exponential_lpdf(vector, vector, vector)
+real double_exponential_lpdf(vector, vector, row_vector)
+real double_exponential_lpdf(vector, vector, real[])
+real double_exponential_lpdf(vector, row_vector, real)
+real double_exponential_lpdf(vector, row_vector, vector)
+real double_exponential_lpdf(vector, row_vector, row_vector)
+real double_exponential_lpdf(vector, row_vector, real[])
+real double_exponential_lpdf(vector, real[], real)
+real double_exponential_lpdf(vector, real[], vector)
+real double_exponential_lpdf(vector, real[], row_vector)
+real double_exponential_lpdf(vector, real[], real[])
+real double_exponential_lpdf(row_vector, real, real)
+real double_exponential_lpdf(row_vector, real, vector)
+real double_exponential_lpdf(row_vector, real, row_vector)
+real double_exponential_lpdf(row_vector, real, real[])
+real double_exponential_lpdf(row_vector, vector, real)
+real double_exponential_lpdf(row_vector, vector, vector)
+real double_exponential_lpdf(row_vector, vector, row_vector)
+real double_exponential_lpdf(row_vector, vector, real[])
+real double_exponential_lpdf(row_vector, row_vector, real)
+real double_exponential_lpdf(row_vector, row_vector, vector)
+real double_exponential_lpdf(row_vector, row_vector, row_vector)
+real double_exponential_lpdf(row_vector, row_vector, real[])
+real double_exponential_lpdf(row_vector, real[], real)
+real double_exponential_lpdf(row_vector, real[], vector)
+real double_exponential_lpdf(row_vector, real[], row_vector)
+real double_exponential_lpdf(row_vector, real[], real[])
+real double_exponential_lpdf(real[], real, vector)
+real double_exponential_lpdf(real[], real, row_vector)
+real double_exponential_lpdf(real[], vector, real)
+real double_exponential_lpdf(real[], vector, vector)
+real double_exponential_lpdf(real[], vector, row_vector)
+real double_exponential_lpdf(real[], vector, real[])
+real double_exponential_lpdf(real[], row_vector, real)
+real double_exponential_lpdf(real[], row_vector, vector)
+real double_exponential_lpdf(real[], row_vector, row_vector)
+real double_exponential_lpdf(real[], row_vector, real[])
+real double_exponential_lpdf(real[], real[], vector)
+real double_exponential_lpdf(real[], real[], row_vector)
+real[] double_exponential_rng(int, vector)
+real[] double_exponential_rng(int, row_vector)
+real[] double_exponential_rng(real, vector)
+real[] double_exponential_rng(real, row_vector)
+real[] double_exponential_rng(vector, int)
+real[] double_exponential_rng(vector, real)
+real[] double_exponential_rng(vector, vector)
+real[] double_exponential_rng(vector, row_vector)
+real[] double_exponential_rng(vector, int[])
+real[] double_exponential_rng(vector, real[])
+real[] double_exponential_rng(row_vector, int)
+real[] double_exponential_rng(row_vector, real)
+real[] double_exponential_rng(row_vector, vector)
+real[] double_exponential_rng(row_vector, row_vector)
+real[] double_exponential_rng(row_vector, int[])
+real[] double_exponential_rng(row_vector, real[])
+real[] double_exponential_rng(int[], vector)
+real[] double_exponential_rng(int[], row_vector)
+real[] double_exponential_rng(real[], vector)
+real[] double_exponential_rng(real[], row_vector)
+real exp_mod_normal_ccdf_log(real, real, real, vector)
+real exp_mod_normal_ccdf_log(real, real, real, row_vector)
+real exp_mod_normal_ccdf_log(real, real, vector, real)
+real exp_mod_normal_ccdf_log(real, real, vector, vector)
+real exp_mod_normal_ccdf_log(real, real, vector, row_vector)
+real exp_mod_normal_ccdf_log(real, real, vector, real[])
+real exp_mod_normal_ccdf_log(real, real, row_vector, real)
+real exp_mod_normal_ccdf_log(real, real, row_vector, vector)
+real exp_mod_normal_ccdf_log(real, real, row_vector, row_vector)
+real exp_mod_normal_ccdf_log(real, real, row_vector, real[])
+real exp_mod_normal_ccdf_log(real, real, real[], vector)
+real exp_mod_normal_ccdf_log(real, real, real[], row_vector)
+real exp_mod_normal_ccdf_log(real, vector, real, real)
+real exp_mod_normal_ccdf_log(real, vector, real, vector)
+real exp_mod_normal_ccdf_log(real, vector, real, row_vector)
+real exp_mod_normal_ccdf_log(real, vector, real, real[])
+real exp_mod_normal_ccdf_log(real, vector, vector, real)
+real exp_mod_normal_ccdf_log(real, vector, vector, vector)
+real exp_mod_normal_ccdf_log(real, vector, vector, row_vector)
+real exp_mod_normal_ccdf_log(real, vector, vector, real[])
+real exp_mod_normal_ccdf_log(real, vector, row_vector, real)
+real exp_mod_normal_ccdf_log(real, vector, row_vector, vector)
+real exp_mod_normal_ccdf_log(real, vector, row_vector, row_vector)
+real exp_mod_normal_ccdf_log(real, vector, row_vector, real[])
+real exp_mod_normal_ccdf_log(real, vector, real[], real)
+real exp_mod_normal_ccdf_log(real, vector, real[], vector)
+real exp_mod_normal_ccdf_log(real, vector, real[], row_vector)
+real exp_mod_normal_ccdf_log(real, vector, real[], real[])
+real exp_mod_normal_ccdf_log(real, row_vector, real, real)
+real exp_mod_normal_ccdf_log(real, row_vector, real, vector)
+real exp_mod_normal_ccdf_log(real, row_vector, real, row_vector)
+real exp_mod_normal_ccdf_log(real, row_vector, real, real[])
+real exp_mod_normal_ccdf_log(real, row_vector, vector, real)
+real exp_mod_normal_ccdf_log(real, row_vector, vector, vector)
+real exp_mod_normal_ccdf_log(real, row_vector, vector, row_vector)
+real exp_mod_normal_ccdf_log(real, row_vector, vector, real[])
+real exp_mod_normal_ccdf_log(real, row_vector, row_vector, real)
+real exp_mod_normal_ccdf_log(real, row_vector, row_vector, vector)
+real exp_mod_normal_ccdf_log(real, row_vector, row_vector, row_vector)
+real exp_mod_normal_ccdf_log(real, row_vector, row_vector, real[])
+real exp_mod_normal_ccdf_log(real, row_vector, real[], real)
+real exp_mod_normal_ccdf_log(real, row_vector, real[], vector)
+real exp_mod_normal_ccdf_log(real, row_vector, real[], row_vector)
+real exp_mod_normal_ccdf_log(real, row_vector, real[], real[])
+real exp_mod_normal_ccdf_log(real, real[], real, vector)
+real exp_mod_normal_ccdf_log(real, real[], real, row_vector)
+real exp_mod_normal_ccdf_log(real, real[], vector, real)
+real exp_mod_normal_ccdf_log(real, real[], vector, vector)
+real exp_mod_normal_ccdf_log(real, real[], vector, row_vector)
+real exp_mod_normal_ccdf_log(real, real[], vector, real[])
+real exp_mod_normal_ccdf_log(real, real[], row_vector, real)
+real exp_mod_normal_ccdf_log(real, real[], row_vector, vector)
+real exp_mod_normal_ccdf_log(real, real[], row_vector, row_vector)
+real exp_mod_normal_ccdf_log(real, real[], row_vector, real[])
+real exp_mod_normal_ccdf_log(real, real[], real[], vector)
+real exp_mod_normal_ccdf_log(real, real[], real[], row_vector)
+real exp_mod_normal_ccdf_log(vector, real, real, real)
+real exp_mod_normal_ccdf_log(vector, real, real, vector)
+real exp_mod_normal_ccdf_log(vector, real, real, row_vector)
+real exp_mod_normal_ccdf_log(vector, real, real, real[])
+real exp_mod_normal_ccdf_log(vector, real, vector, real)
+real exp_mod_normal_ccdf_log(vector, real, vector, vector)
+real exp_mod_normal_ccdf_log(vector, real, vector, row_vector)
+real exp_mod_normal_ccdf_log(vector, real, vector, real[])
+real exp_mod_normal_ccdf_log(vector, real, row_vector, real)
+real exp_mod_normal_ccdf_log(vector, real, row_vector, vector)
+real exp_mod_normal_ccdf_log(vector, real, row_vector, row_vector)
+real exp_mod_normal_ccdf_log(vector, real, row_vector, real[])
+real exp_mod_normal_ccdf_log(vector, real, real[], real)
+real exp_mod_normal_ccdf_log(vector, real, real[], vector)
+real exp_mod_normal_ccdf_log(vector, real, real[], row_vector)
+real exp_mod_normal_ccdf_log(vector, real, real[], real[])
+real exp_mod_normal_ccdf_log(vector, vector, real, real)
+real exp_mod_normal_ccdf_log(vector, vector, real, vector)
+real exp_mod_normal_ccdf_log(vector, vector, real, row_vector)
+real exp_mod_normal_ccdf_log(vector, vector, real, real[])
+real exp_mod_normal_ccdf_log(vector, vector, vector, real)
+real exp_mod_normal_ccdf_log(vector, vector, vector, vector)
+real exp_mod_normal_ccdf_log(vector, vector, vector, row_vector)
+real exp_mod_normal_ccdf_log(vector, vector, vector, real[])
+real exp_mod_normal_ccdf_log(vector, vector, row_vector, real)
+real exp_mod_normal_ccdf_log(vector, vector, row_vector, vector)
+real exp_mod_normal_ccdf_log(vector, vector, row_vector, row_vector)
+real exp_mod_normal_ccdf_log(vector, vector, row_vector, real[])
+real exp_mod_normal_ccdf_log(vector, vector, real[], real)
+real exp_mod_normal_ccdf_log(vector, vector, real[], vector)
+real exp_mod_normal_ccdf_log(vector, vector, real[], row_vector)
+real exp_mod_normal_ccdf_log(vector, vector, real[], real[])
+real exp_mod_normal_ccdf_log(vector, row_vector, real, real)
+real exp_mod_normal_ccdf_log(vector, row_vector, real, vector)
+real exp_mod_normal_ccdf_log(vector, row_vector, real, row_vector)
+real exp_mod_normal_ccdf_log(vector, row_vector, real, real[])
+real exp_mod_normal_ccdf_log(vector, row_vector, vector, real)
+real exp_mod_normal_ccdf_log(vector, row_vector, vector, vector)
+real exp_mod_normal_ccdf_log(vector, row_vector, vector, row_vector)
+real exp_mod_normal_ccdf_log(vector, row_vector, vector, real[])
+real exp_mod_normal_ccdf_log(vector, row_vector, row_vector, real)
+real exp_mod_normal_ccdf_log(vector, row_vector, row_vector, vector)
+real exp_mod_normal_ccdf_log(vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_ccdf_log(vector, row_vector, row_vector, real[])
+real exp_mod_normal_ccdf_log(vector, row_vector, real[], real)
+real exp_mod_normal_ccdf_log(vector, row_vector, real[], vector)
+real exp_mod_normal_ccdf_log(vector, row_vector, real[], row_vector)
+real exp_mod_normal_ccdf_log(vector, row_vector, real[], real[])
+real exp_mod_normal_ccdf_log(vector, real[], real, real)
+real exp_mod_normal_ccdf_log(vector, real[], real, vector)
+real exp_mod_normal_ccdf_log(vector, real[], real, row_vector)
+real exp_mod_normal_ccdf_log(vector, real[], real, real[])
+real exp_mod_normal_ccdf_log(vector, real[], vector, real)
+real exp_mod_normal_ccdf_log(vector, real[], vector, vector)
+real exp_mod_normal_ccdf_log(vector, real[], vector, row_vector)
+real exp_mod_normal_ccdf_log(vector, real[], vector, real[])
+real exp_mod_normal_ccdf_log(vector, real[], row_vector, real)
+real exp_mod_normal_ccdf_log(vector, real[], row_vector, vector)
+real exp_mod_normal_ccdf_log(vector, real[], row_vector, row_vector)
+real exp_mod_normal_ccdf_log(vector, real[], row_vector, real[])
+real exp_mod_normal_ccdf_log(vector, real[], real[], real)
+real exp_mod_normal_ccdf_log(vector, real[], real[], vector)
+real exp_mod_normal_ccdf_log(vector, real[], real[], row_vector)
+real exp_mod_normal_ccdf_log(vector, real[], real[], real[])
+real exp_mod_normal_ccdf_log(row_vector, real, real, real)
+real exp_mod_normal_ccdf_log(row_vector, real, real, vector)
+real exp_mod_normal_ccdf_log(row_vector, real, real, row_vector)
+real exp_mod_normal_ccdf_log(row_vector, real, real, real[])
+real exp_mod_normal_ccdf_log(row_vector, real, vector, real)
+real exp_mod_normal_ccdf_log(row_vector, real, vector, vector)
+real exp_mod_normal_ccdf_log(row_vector, real, vector, row_vector)
+real exp_mod_normal_ccdf_log(row_vector, real, vector, real[])
+real exp_mod_normal_ccdf_log(row_vector, real, row_vector, real)
+real exp_mod_normal_ccdf_log(row_vector, real, row_vector, vector)
+real exp_mod_normal_ccdf_log(row_vector, real, row_vector, row_vector)
+real exp_mod_normal_ccdf_log(row_vector, real, row_vector, real[])
+real exp_mod_normal_ccdf_log(row_vector, real, real[], real)
+real exp_mod_normal_ccdf_log(row_vector, real, real[], vector)
+real exp_mod_normal_ccdf_log(row_vector, real, real[], row_vector)
+real exp_mod_normal_ccdf_log(row_vector, real, real[], real[])
+real exp_mod_normal_ccdf_log(row_vector, vector, real, real)
+real exp_mod_normal_ccdf_log(row_vector, vector, real, vector)
+real exp_mod_normal_ccdf_log(row_vector, vector, real, row_vector)
+real exp_mod_normal_ccdf_log(row_vector, vector, real, real[])
+real exp_mod_normal_ccdf_log(row_vector, vector, vector, real)
+real exp_mod_normal_ccdf_log(row_vector, vector, vector, vector)
+real exp_mod_normal_ccdf_log(row_vector, vector, vector, row_vector)
+real exp_mod_normal_ccdf_log(row_vector, vector, vector, real[])
+real exp_mod_normal_ccdf_log(row_vector, vector, row_vector, real)
+real exp_mod_normal_ccdf_log(row_vector, vector, row_vector, vector)
+real exp_mod_normal_ccdf_log(row_vector, vector, row_vector, row_vector)
+real exp_mod_normal_ccdf_log(row_vector, vector, row_vector, real[])
+real exp_mod_normal_ccdf_log(row_vector, vector, real[], real)
+real exp_mod_normal_ccdf_log(row_vector, vector, real[], vector)
+real exp_mod_normal_ccdf_log(row_vector, vector, real[], row_vector)
+real exp_mod_normal_ccdf_log(row_vector, vector, real[], real[])
+real exp_mod_normal_ccdf_log(row_vector, row_vector, real, real)
+real exp_mod_normal_ccdf_log(row_vector, row_vector, real, vector)
+real exp_mod_normal_ccdf_log(row_vector, row_vector, real, row_vector)
+real exp_mod_normal_ccdf_log(row_vector, row_vector, real, real[])
+real exp_mod_normal_ccdf_log(row_vector, row_vector, vector, real)
+real exp_mod_normal_ccdf_log(row_vector, row_vector, vector, vector)
+real exp_mod_normal_ccdf_log(row_vector, row_vector, vector, row_vector)
+real exp_mod_normal_ccdf_log(row_vector, row_vector, vector, real[])
+real exp_mod_normal_ccdf_log(row_vector, row_vector, row_vector, real)
+real exp_mod_normal_ccdf_log(row_vector, row_vector, row_vector, vector)
+real exp_mod_normal_ccdf_log(row_vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_ccdf_log(row_vector, row_vector, row_vector, real[])
+real exp_mod_normal_ccdf_log(row_vector, row_vector, real[], real)
+real exp_mod_normal_ccdf_log(row_vector, row_vector, real[], vector)
+real exp_mod_normal_ccdf_log(row_vector, row_vector, real[], row_vector)
+real exp_mod_normal_ccdf_log(row_vector, row_vector, real[], real[])
+real exp_mod_normal_ccdf_log(row_vector, real[], real, real)
+real exp_mod_normal_ccdf_log(row_vector, real[], real, vector)
+real exp_mod_normal_ccdf_log(row_vector, real[], real, row_vector)
+real exp_mod_normal_ccdf_log(row_vector, real[], real, real[])
+real exp_mod_normal_ccdf_log(row_vector, real[], vector, real)
+real exp_mod_normal_ccdf_log(row_vector, real[], vector, vector)
+real exp_mod_normal_ccdf_log(row_vector, real[], vector, row_vector)
+real exp_mod_normal_ccdf_log(row_vector, real[], vector, real[])
+real exp_mod_normal_ccdf_log(row_vector, real[], row_vector, real)
+real exp_mod_normal_ccdf_log(row_vector, real[], row_vector, vector)
+real exp_mod_normal_ccdf_log(row_vector, real[], row_vector, row_vector)
+real exp_mod_normal_ccdf_log(row_vector, real[], row_vector, real[])
+real exp_mod_normal_ccdf_log(row_vector, real[], real[], real)
+real exp_mod_normal_ccdf_log(row_vector, real[], real[], vector)
+real exp_mod_normal_ccdf_log(row_vector, real[], real[], row_vector)
+real exp_mod_normal_ccdf_log(row_vector, real[], real[], real[])
+real exp_mod_normal_ccdf_log(real[], real, real, vector)
+real exp_mod_normal_ccdf_log(real[], real, real, row_vector)
+real exp_mod_normal_ccdf_log(real[], real, vector, real)
+real exp_mod_normal_ccdf_log(real[], real, vector, vector)
+real exp_mod_normal_ccdf_log(real[], real, vector, row_vector)
+real exp_mod_normal_ccdf_log(real[], real, vector, real[])
+real exp_mod_normal_ccdf_log(real[], real, row_vector, real)
+real exp_mod_normal_ccdf_log(real[], real, row_vector, vector)
+real exp_mod_normal_ccdf_log(real[], real, row_vector, row_vector)
+real exp_mod_normal_ccdf_log(real[], real, row_vector, real[])
+real exp_mod_normal_ccdf_log(real[], real, real[], vector)
+real exp_mod_normal_ccdf_log(real[], real, real[], row_vector)
+real exp_mod_normal_ccdf_log(real[], vector, real, real)
+real exp_mod_normal_ccdf_log(real[], vector, real, vector)
+real exp_mod_normal_ccdf_log(real[], vector, real, row_vector)
+real exp_mod_normal_ccdf_log(real[], vector, real, real[])
+real exp_mod_normal_ccdf_log(real[], vector, vector, real)
+real exp_mod_normal_ccdf_log(real[], vector, vector, vector)
+real exp_mod_normal_ccdf_log(real[], vector, vector, row_vector)
+real exp_mod_normal_ccdf_log(real[], vector, vector, real[])
+real exp_mod_normal_ccdf_log(real[], vector, row_vector, real)
+real exp_mod_normal_ccdf_log(real[], vector, row_vector, vector)
+real exp_mod_normal_ccdf_log(real[], vector, row_vector, row_vector)
+real exp_mod_normal_ccdf_log(real[], vector, row_vector, real[])
+real exp_mod_normal_ccdf_log(real[], vector, real[], real)
+real exp_mod_normal_ccdf_log(real[], vector, real[], vector)
+real exp_mod_normal_ccdf_log(real[], vector, real[], row_vector)
+real exp_mod_normal_ccdf_log(real[], vector, real[], real[])
+real exp_mod_normal_ccdf_log(real[], row_vector, real, real)
+real exp_mod_normal_ccdf_log(real[], row_vector, real, vector)
+real exp_mod_normal_ccdf_log(real[], row_vector, real, row_vector)
+real exp_mod_normal_ccdf_log(real[], row_vector, real, real[])
+real exp_mod_normal_ccdf_log(real[], row_vector, vector, real)
+real exp_mod_normal_ccdf_log(real[], row_vector, vector, vector)
+real exp_mod_normal_ccdf_log(real[], row_vector, vector, row_vector)
+real exp_mod_normal_ccdf_log(real[], row_vector, vector, real[])
+real exp_mod_normal_ccdf_log(real[], row_vector, row_vector, real)
+real exp_mod_normal_ccdf_log(real[], row_vector, row_vector, vector)
+real exp_mod_normal_ccdf_log(real[], row_vector, row_vector, row_vector)
+real exp_mod_normal_ccdf_log(real[], row_vector, row_vector, real[])
+real exp_mod_normal_ccdf_log(real[], row_vector, real[], real)
+real exp_mod_normal_ccdf_log(real[], row_vector, real[], vector)
+real exp_mod_normal_ccdf_log(real[], row_vector, real[], row_vector)
+real exp_mod_normal_ccdf_log(real[], row_vector, real[], real[])
+real exp_mod_normal_ccdf_log(real[], real[], real, vector)
+real exp_mod_normal_ccdf_log(real[], real[], real, row_vector)
+real exp_mod_normal_ccdf_log(real[], real[], vector, real)
+real exp_mod_normal_ccdf_log(real[], real[], vector, vector)
+real exp_mod_normal_ccdf_log(real[], real[], vector, row_vector)
+real exp_mod_normal_ccdf_log(real[], real[], vector, real[])
+real exp_mod_normal_ccdf_log(real[], real[], row_vector, real)
+real exp_mod_normal_ccdf_log(real[], real[], row_vector, vector)
+real exp_mod_normal_ccdf_log(real[], real[], row_vector, row_vector)
+real exp_mod_normal_ccdf_log(real[], real[], row_vector, real[])
+real exp_mod_normal_ccdf_log(real[], real[], real[], vector)
+real exp_mod_normal_ccdf_log(real[], real[], real[], row_vector)
+real exp_mod_normal_cdf(real, real, real, vector)
+real exp_mod_normal_cdf(real, real, real, row_vector)
+real exp_mod_normal_cdf(real, real, vector, real)
+real exp_mod_normal_cdf(real, real, vector, vector)
+real exp_mod_normal_cdf(real, real, vector, row_vector)
+real exp_mod_normal_cdf(real, real, vector, real[])
+real exp_mod_normal_cdf(real, real, row_vector, real)
+real exp_mod_normal_cdf(real, real, row_vector, vector)
+real exp_mod_normal_cdf(real, real, row_vector, row_vector)
+real exp_mod_normal_cdf(real, real, row_vector, real[])
+real exp_mod_normal_cdf(real, real, real[], vector)
+real exp_mod_normal_cdf(real, real, real[], row_vector)
+real exp_mod_normal_cdf(real, vector, real, real)
+real exp_mod_normal_cdf(real, vector, real, vector)
+real exp_mod_normal_cdf(real, vector, real, row_vector)
+real exp_mod_normal_cdf(real, vector, real, real[])
+real exp_mod_normal_cdf(real, vector, vector, real)
+real exp_mod_normal_cdf(real, vector, vector, vector)
+real exp_mod_normal_cdf(real, vector, vector, row_vector)
+real exp_mod_normal_cdf(real, vector, vector, real[])
+real exp_mod_normal_cdf(real, vector, row_vector, real)
+real exp_mod_normal_cdf(real, vector, row_vector, vector)
+real exp_mod_normal_cdf(real, vector, row_vector, row_vector)
+real exp_mod_normal_cdf(real, vector, row_vector, real[])
+real exp_mod_normal_cdf(real, vector, real[], real)
+real exp_mod_normal_cdf(real, vector, real[], vector)
+real exp_mod_normal_cdf(real, vector, real[], row_vector)
+real exp_mod_normal_cdf(real, vector, real[], real[])
+real exp_mod_normal_cdf(real, row_vector, real, real)
+real exp_mod_normal_cdf(real, row_vector, real, vector)
+real exp_mod_normal_cdf(real, row_vector, real, row_vector)
+real exp_mod_normal_cdf(real, row_vector, real, real[])
+real exp_mod_normal_cdf(real, row_vector, vector, real)
+real exp_mod_normal_cdf(real, row_vector, vector, vector)
+real exp_mod_normal_cdf(real, row_vector, vector, row_vector)
+real exp_mod_normal_cdf(real, row_vector, vector, real[])
+real exp_mod_normal_cdf(real, row_vector, row_vector, real)
+real exp_mod_normal_cdf(real, row_vector, row_vector, vector)
+real exp_mod_normal_cdf(real, row_vector, row_vector, row_vector)
+real exp_mod_normal_cdf(real, row_vector, row_vector, real[])
+real exp_mod_normal_cdf(real, row_vector, real[], real)
+real exp_mod_normal_cdf(real, row_vector, real[], vector)
+real exp_mod_normal_cdf(real, row_vector, real[], row_vector)
+real exp_mod_normal_cdf(real, row_vector, real[], real[])
+real exp_mod_normal_cdf(real, real[], real, vector)
+real exp_mod_normal_cdf(real, real[], real, row_vector)
+real exp_mod_normal_cdf(real, real[], vector, real)
+real exp_mod_normal_cdf(real, real[], vector, vector)
+real exp_mod_normal_cdf(real, real[], vector, row_vector)
+real exp_mod_normal_cdf(real, real[], vector, real[])
+real exp_mod_normal_cdf(real, real[], row_vector, real)
+real exp_mod_normal_cdf(real, real[], row_vector, vector)
+real exp_mod_normal_cdf(real, real[], row_vector, row_vector)
+real exp_mod_normal_cdf(real, real[], row_vector, real[])
+real exp_mod_normal_cdf(real, real[], real[], vector)
+real exp_mod_normal_cdf(real, real[], real[], row_vector)
+real exp_mod_normal_cdf(vector, real, real, real)
+real exp_mod_normal_cdf(vector, real, real, vector)
+real exp_mod_normal_cdf(vector, real, real, row_vector)
+real exp_mod_normal_cdf(vector, real, real, real[])
+real exp_mod_normal_cdf(vector, real, vector, real)
+real exp_mod_normal_cdf(vector, real, vector, vector)
+real exp_mod_normal_cdf(vector, real, vector, row_vector)
+real exp_mod_normal_cdf(vector, real, vector, real[])
+real exp_mod_normal_cdf(vector, real, row_vector, real)
+real exp_mod_normal_cdf(vector, real, row_vector, vector)
+real exp_mod_normal_cdf(vector, real, row_vector, row_vector)
+real exp_mod_normal_cdf(vector, real, row_vector, real[])
+real exp_mod_normal_cdf(vector, real, real[], real)
+real exp_mod_normal_cdf(vector, real, real[], vector)
+real exp_mod_normal_cdf(vector, real, real[], row_vector)
+real exp_mod_normal_cdf(vector, real, real[], real[])
+real exp_mod_normal_cdf(vector, vector, real, real)
+real exp_mod_normal_cdf(vector, vector, real, vector)
+real exp_mod_normal_cdf(vector, vector, real, row_vector)
+real exp_mod_normal_cdf(vector, vector, real, real[])
+real exp_mod_normal_cdf(vector, vector, vector, real)
+real exp_mod_normal_cdf(vector, vector, vector, vector)
+real exp_mod_normal_cdf(vector, vector, vector, row_vector)
+real exp_mod_normal_cdf(vector, vector, vector, real[])
+real exp_mod_normal_cdf(vector, vector, row_vector, real)
+real exp_mod_normal_cdf(vector, vector, row_vector, vector)
+real exp_mod_normal_cdf(vector, vector, row_vector, row_vector)
+real exp_mod_normal_cdf(vector, vector, row_vector, real[])
+real exp_mod_normal_cdf(vector, vector, real[], real)
+real exp_mod_normal_cdf(vector, vector, real[], vector)
+real exp_mod_normal_cdf(vector, vector, real[], row_vector)
+real exp_mod_normal_cdf(vector, vector, real[], real[])
+real exp_mod_normal_cdf(vector, row_vector, real, real)
+real exp_mod_normal_cdf(vector, row_vector, real, vector)
+real exp_mod_normal_cdf(vector, row_vector, real, row_vector)
+real exp_mod_normal_cdf(vector, row_vector, real, real[])
+real exp_mod_normal_cdf(vector, row_vector, vector, real)
+real exp_mod_normal_cdf(vector, row_vector, vector, vector)
+real exp_mod_normal_cdf(vector, row_vector, vector, row_vector)
+real exp_mod_normal_cdf(vector, row_vector, vector, real[])
+real exp_mod_normal_cdf(vector, row_vector, row_vector, real)
+real exp_mod_normal_cdf(vector, row_vector, row_vector, vector)
+real exp_mod_normal_cdf(vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_cdf(vector, row_vector, row_vector, real[])
+real exp_mod_normal_cdf(vector, row_vector, real[], real)
+real exp_mod_normal_cdf(vector, row_vector, real[], vector)
+real exp_mod_normal_cdf(vector, row_vector, real[], row_vector)
+real exp_mod_normal_cdf(vector, row_vector, real[], real[])
+real exp_mod_normal_cdf(vector, real[], real, real)
+real exp_mod_normal_cdf(vector, real[], real, vector)
+real exp_mod_normal_cdf(vector, real[], real, row_vector)
+real exp_mod_normal_cdf(vector, real[], real, real[])
+real exp_mod_normal_cdf(vector, real[], vector, real)
+real exp_mod_normal_cdf(vector, real[], vector, vector)
+real exp_mod_normal_cdf(vector, real[], vector, row_vector)
+real exp_mod_normal_cdf(vector, real[], vector, real[])
+real exp_mod_normal_cdf(vector, real[], row_vector, real)
+real exp_mod_normal_cdf(vector, real[], row_vector, vector)
+real exp_mod_normal_cdf(vector, real[], row_vector, row_vector)
+real exp_mod_normal_cdf(vector, real[], row_vector, real[])
+real exp_mod_normal_cdf(vector, real[], real[], real)
+real exp_mod_normal_cdf(vector, real[], real[], vector)
+real exp_mod_normal_cdf(vector, real[], real[], row_vector)
+real exp_mod_normal_cdf(vector, real[], real[], real[])
+real exp_mod_normal_cdf(row_vector, real, real, real)
+real exp_mod_normal_cdf(row_vector, real, real, vector)
+real exp_mod_normal_cdf(row_vector, real, real, row_vector)
+real exp_mod_normal_cdf(row_vector, real, real, real[])
+real exp_mod_normal_cdf(row_vector, real, vector, real)
+real exp_mod_normal_cdf(row_vector, real, vector, vector)
+real exp_mod_normal_cdf(row_vector, real, vector, row_vector)
+real exp_mod_normal_cdf(row_vector, real, vector, real[])
+real exp_mod_normal_cdf(row_vector, real, row_vector, real)
+real exp_mod_normal_cdf(row_vector, real, row_vector, vector)
+real exp_mod_normal_cdf(row_vector, real, row_vector, row_vector)
+real exp_mod_normal_cdf(row_vector, real, row_vector, real[])
+real exp_mod_normal_cdf(row_vector, real, real[], real)
+real exp_mod_normal_cdf(row_vector, real, real[], vector)
+real exp_mod_normal_cdf(row_vector, real, real[], row_vector)
+real exp_mod_normal_cdf(row_vector, real, real[], real[])
+real exp_mod_normal_cdf(row_vector, vector, real, real)
+real exp_mod_normal_cdf(row_vector, vector, real, vector)
+real exp_mod_normal_cdf(row_vector, vector, real, row_vector)
+real exp_mod_normal_cdf(row_vector, vector, real, real[])
+real exp_mod_normal_cdf(row_vector, vector, vector, real)
+real exp_mod_normal_cdf(row_vector, vector, vector, vector)
+real exp_mod_normal_cdf(row_vector, vector, vector, row_vector)
+real exp_mod_normal_cdf(row_vector, vector, vector, real[])
+real exp_mod_normal_cdf(row_vector, vector, row_vector, real)
+real exp_mod_normal_cdf(row_vector, vector, row_vector, vector)
+real exp_mod_normal_cdf(row_vector, vector, row_vector, row_vector)
+real exp_mod_normal_cdf(row_vector, vector, row_vector, real[])
+real exp_mod_normal_cdf(row_vector, vector, real[], real)
+real exp_mod_normal_cdf(row_vector, vector, real[], vector)
+real exp_mod_normal_cdf(row_vector, vector, real[], row_vector)
+real exp_mod_normal_cdf(row_vector, vector, real[], real[])
+real exp_mod_normal_cdf(row_vector, row_vector, real, real)
+real exp_mod_normal_cdf(row_vector, row_vector, real, vector)
+real exp_mod_normal_cdf(row_vector, row_vector, real, row_vector)
+real exp_mod_normal_cdf(row_vector, row_vector, real, real[])
+real exp_mod_normal_cdf(row_vector, row_vector, vector, real)
+real exp_mod_normal_cdf(row_vector, row_vector, vector, vector)
+real exp_mod_normal_cdf(row_vector, row_vector, vector, row_vector)
+real exp_mod_normal_cdf(row_vector, row_vector, vector, real[])
+real exp_mod_normal_cdf(row_vector, row_vector, row_vector, real)
+real exp_mod_normal_cdf(row_vector, row_vector, row_vector, vector)
+real exp_mod_normal_cdf(row_vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_cdf(row_vector, row_vector, row_vector, real[])
+real exp_mod_normal_cdf(row_vector, row_vector, real[], real)
+real exp_mod_normal_cdf(row_vector, row_vector, real[], vector)
+real exp_mod_normal_cdf(row_vector, row_vector, real[], row_vector)
+real exp_mod_normal_cdf(row_vector, row_vector, real[], real[])
+real exp_mod_normal_cdf(row_vector, real[], real, real)
+real exp_mod_normal_cdf(row_vector, real[], real, vector)
+real exp_mod_normal_cdf(row_vector, real[], real, row_vector)
+real exp_mod_normal_cdf(row_vector, real[], real, real[])
+real exp_mod_normal_cdf(row_vector, real[], vector, real)
+real exp_mod_normal_cdf(row_vector, real[], vector, vector)
+real exp_mod_normal_cdf(row_vector, real[], vector, row_vector)
+real exp_mod_normal_cdf(row_vector, real[], vector, real[])
+real exp_mod_normal_cdf(row_vector, real[], row_vector, real)
+real exp_mod_normal_cdf(row_vector, real[], row_vector, vector)
+real exp_mod_normal_cdf(row_vector, real[], row_vector, row_vector)
+real exp_mod_normal_cdf(row_vector, real[], row_vector, real[])
+real exp_mod_normal_cdf(row_vector, real[], real[], real)
+real exp_mod_normal_cdf(row_vector, real[], real[], vector)
+real exp_mod_normal_cdf(row_vector, real[], real[], row_vector)
+real exp_mod_normal_cdf(row_vector, real[], real[], real[])
+real exp_mod_normal_cdf(real[], real, real, vector)
+real exp_mod_normal_cdf(real[], real, real, row_vector)
+real exp_mod_normal_cdf(real[], real, vector, real)
+real exp_mod_normal_cdf(real[], real, vector, vector)
+real exp_mod_normal_cdf(real[], real, vector, row_vector)
+real exp_mod_normal_cdf(real[], real, vector, real[])
+real exp_mod_normal_cdf(real[], real, row_vector, real)
+real exp_mod_normal_cdf(real[], real, row_vector, vector)
+real exp_mod_normal_cdf(real[], real, row_vector, row_vector)
+real exp_mod_normal_cdf(real[], real, row_vector, real[])
+real exp_mod_normal_cdf(real[], real, real[], vector)
+real exp_mod_normal_cdf(real[], real, real[], row_vector)
+real exp_mod_normal_cdf(real[], vector, real, real)
+real exp_mod_normal_cdf(real[], vector, real, vector)
+real exp_mod_normal_cdf(real[], vector, real, row_vector)
+real exp_mod_normal_cdf(real[], vector, real, real[])
+real exp_mod_normal_cdf(real[], vector, vector, real)
+real exp_mod_normal_cdf(real[], vector, vector, vector)
+real exp_mod_normal_cdf(real[], vector, vector, row_vector)
+real exp_mod_normal_cdf(real[], vector, vector, real[])
+real exp_mod_normal_cdf(real[], vector, row_vector, real)
+real exp_mod_normal_cdf(real[], vector, row_vector, vector)
+real exp_mod_normal_cdf(real[], vector, row_vector, row_vector)
+real exp_mod_normal_cdf(real[], vector, row_vector, real[])
+real exp_mod_normal_cdf(real[], vector, real[], real)
+real exp_mod_normal_cdf(real[], vector, real[], vector)
+real exp_mod_normal_cdf(real[], vector, real[], row_vector)
+real exp_mod_normal_cdf(real[], vector, real[], real[])
+real exp_mod_normal_cdf(real[], row_vector, real, real)
+real exp_mod_normal_cdf(real[], row_vector, real, vector)
+real exp_mod_normal_cdf(real[], row_vector, real, row_vector)
+real exp_mod_normal_cdf(real[], row_vector, real, real[])
+real exp_mod_normal_cdf(real[], row_vector, vector, real)
+real exp_mod_normal_cdf(real[], row_vector, vector, vector)
+real exp_mod_normal_cdf(real[], row_vector, vector, row_vector)
+real exp_mod_normal_cdf(real[], row_vector, vector, real[])
+real exp_mod_normal_cdf(real[], row_vector, row_vector, real)
+real exp_mod_normal_cdf(real[], row_vector, row_vector, vector)
+real exp_mod_normal_cdf(real[], row_vector, row_vector, row_vector)
+real exp_mod_normal_cdf(real[], row_vector, row_vector, real[])
+real exp_mod_normal_cdf(real[], row_vector, real[], real)
+real exp_mod_normal_cdf(real[], row_vector, real[], vector)
+real exp_mod_normal_cdf(real[], row_vector, real[], row_vector)
+real exp_mod_normal_cdf(real[], row_vector, real[], real[])
+real exp_mod_normal_cdf(real[], real[], real, vector)
+real exp_mod_normal_cdf(real[], real[], real, row_vector)
+real exp_mod_normal_cdf(real[], real[], vector, real)
+real exp_mod_normal_cdf(real[], real[], vector, vector)
+real exp_mod_normal_cdf(real[], real[], vector, row_vector)
+real exp_mod_normal_cdf(real[], real[], vector, real[])
+real exp_mod_normal_cdf(real[], real[], row_vector, real)
+real exp_mod_normal_cdf(real[], real[], row_vector, vector)
+real exp_mod_normal_cdf(real[], real[], row_vector, row_vector)
+real exp_mod_normal_cdf(real[], real[], row_vector, real[])
+real exp_mod_normal_cdf(real[], real[], real[], vector)
+real exp_mod_normal_cdf(real[], real[], real[], row_vector)
+real exp_mod_normal_cdf_log(real, real, real, vector)
+real exp_mod_normal_cdf_log(real, real, real, row_vector)
+real exp_mod_normal_cdf_log(real, real, vector, real)
+real exp_mod_normal_cdf_log(real, real, vector, vector)
+real exp_mod_normal_cdf_log(real, real, vector, row_vector)
+real exp_mod_normal_cdf_log(real, real, vector, real[])
+real exp_mod_normal_cdf_log(real, real, row_vector, real)
+real exp_mod_normal_cdf_log(real, real, row_vector, vector)
+real exp_mod_normal_cdf_log(real, real, row_vector, row_vector)
+real exp_mod_normal_cdf_log(real, real, row_vector, real[])
+real exp_mod_normal_cdf_log(real, real, real[], vector)
+real exp_mod_normal_cdf_log(real, real, real[], row_vector)
+real exp_mod_normal_cdf_log(real, vector, real, real)
+real exp_mod_normal_cdf_log(real, vector, real, vector)
+real exp_mod_normal_cdf_log(real, vector, real, row_vector)
+real exp_mod_normal_cdf_log(real, vector, real, real[])
+real exp_mod_normal_cdf_log(real, vector, vector, real)
+real exp_mod_normal_cdf_log(real, vector, vector, vector)
+real exp_mod_normal_cdf_log(real, vector, vector, row_vector)
+real exp_mod_normal_cdf_log(real, vector, vector, real[])
+real exp_mod_normal_cdf_log(real, vector, row_vector, real)
+real exp_mod_normal_cdf_log(real, vector, row_vector, vector)
+real exp_mod_normal_cdf_log(real, vector, row_vector, row_vector)
+real exp_mod_normal_cdf_log(real, vector, row_vector, real[])
+real exp_mod_normal_cdf_log(real, vector, real[], real)
+real exp_mod_normal_cdf_log(real, vector, real[], vector)
+real exp_mod_normal_cdf_log(real, vector, real[], row_vector)
+real exp_mod_normal_cdf_log(real, vector, real[], real[])
+real exp_mod_normal_cdf_log(real, row_vector, real, real)
+real exp_mod_normal_cdf_log(real, row_vector, real, vector)
+real exp_mod_normal_cdf_log(real, row_vector, real, row_vector)
+real exp_mod_normal_cdf_log(real, row_vector, real, real[])
+real exp_mod_normal_cdf_log(real, row_vector, vector, real)
+real exp_mod_normal_cdf_log(real, row_vector, vector, vector)
+real exp_mod_normal_cdf_log(real, row_vector, vector, row_vector)
+real exp_mod_normal_cdf_log(real, row_vector, vector, real[])
+real exp_mod_normal_cdf_log(real, row_vector, row_vector, real)
+real exp_mod_normal_cdf_log(real, row_vector, row_vector, vector)
+real exp_mod_normal_cdf_log(real, row_vector, row_vector, row_vector)
+real exp_mod_normal_cdf_log(real, row_vector, row_vector, real[])
+real exp_mod_normal_cdf_log(real, row_vector, real[], real)
+real exp_mod_normal_cdf_log(real, row_vector, real[], vector)
+real exp_mod_normal_cdf_log(real, row_vector, real[], row_vector)
+real exp_mod_normal_cdf_log(real, row_vector, real[], real[])
+real exp_mod_normal_cdf_log(real, real[], real, vector)
+real exp_mod_normal_cdf_log(real, real[], real, row_vector)
+real exp_mod_normal_cdf_log(real, real[], vector, real)
+real exp_mod_normal_cdf_log(real, real[], vector, vector)
+real exp_mod_normal_cdf_log(real, real[], vector, row_vector)
+real exp_mod_normal_cdf_log(real, real[], vector, real[])
+real exp_mod_normal_cdf_log(real, real[], row_vector, real)
+real exp_mod_normal_cdf_log(real, real[], row_vector, vector)
+real exp_mod_normal_cdf_log(real, real[], row_vector, row_vector)
+real exp_mod_normal_cdf_log(real, real[], row_vector, real[])
+real exp_mod_normal_cdf_log(real, real[], real[], vector)
+real exp_mod_normal_cdf_log(real, real[], real[], row_vector)
+real exp_mod_normal_cdf_log(vector, real, real, real)
+real exp_mod_normal_cdf_log(vector, real, real, vector)
+real exp_mod_normal_cdf_log(vector, real, real, row_vector)
+real exp_mod_normal_cdf_log(vector, real, real, real[])
+real exp_mod_normal_cdf_log(vector, real, vector, real)
+real exp_mod_normal_cdf_log(vector, real, vector, vector)
+real exp_mod_normal_cdf_log(vector, real, vector, row_vector)
+real exp_mod_normal_cdf_log(vector, real, vector, real[])
+real exp_mod_normal_cdf_log(vector, real, row_vector, real)
+real exp_mod_normal_cdf_log(vector, real, row_vector, vector)
+real exp_mod_normal_cdf_log(vector, real, row_vector, row_vector)
+real exp_mod_normal_cdf_log(vector, real, row_vector, real[])
+real exp_mod_normal_cdf_log(vector, real, real[], real)
+real exp_mod_normal_cdf_log(vector, real, real[], vector)
+real exp_mod_normal_cdf_log(vector, real, real[], row_vector)
+real exp_mod_normal_cdf_log(vector, real, real[], real[])
+real exp_mod_normal_cdf_log(vector, vector, real, real)
+real exp_mod_normal_cdf_log(vector, vector, real, vector)
+real exp_mod_normal_cdf_log(vector, vector, real, row_vector)
+real exp_mod_normal_cdf_log(vector, vector, real, real[])
+real exp_mod_normal_cdf_log(vector, vector, vector, real)
+real exp_mod_normal_cdf_log(vector, vector, vector, vector)
+real exp_mod_normal_cdf_log(vector, vector, vector, row_vector)
+real exp_mod_normal_cdf_log(vector, vector, vector, real[])
+real exp_mod_normal_cdf_log(vector, vector, row_vector, real)
+real exp_mod_normal_cdf_log(vector, vector, row_vector, vector)
+real exp_mod_normal_cdf_log(vector, vector, row_vector, row_vector)
+real exp_mod_normal_cdf_log(vector, vector, row_vector, real[])
+real exp_mod_normal_cdf_log(vector, vector, real[], real)
+real exp_mod_normal_cdf_log(vector, vector, real[], vector)
+real exp_mod_normal_cdf_log(vector, vector, real[], row_vector)
+real exp_mod_normal_cdf_log(vector, vector, real[], real[])
+real exp_mod_normal_cdf_log(vector, row_vector, real, real)
+real exp_mod_normal_cdf_log(vector, row_vector, real, vector)
+real exp_mod_normal_cdf_log(vector, row_vector, real, row_vector)
+real exp_mod_normal_cdf_log(vector, row_vector, real, real[])
+real exp_mod_normal_cdf_log(vector, row_vector, vector, real)
+real exp_mod_normal_cdf_log(vector, row_vector, vector, vector)
+real exp_mod_normal_cdf_log(vector, row_vector, vector, row_vector)
+real exp_mod_normal_cdf_log(vector, row_vector, vector, real[])
+real exp_mod_normal_cdf_log(vector, row_vector, row_vector, real)
+real exp_mod_normal_cdf_log(vector, row_vector, row_vector, vector)
+real exp_mod_normal_cdf_log(vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_cdf_log(vector, row_vector, row_vector, real[])
+real exp_mod_normal_cdf_log(vector, row_vector, real[], real)
+real exp_mod_normal_cdf_log(vector, row_vector, real[], vector)
+real exp_mod_normal_cdf_log(vector, row_vector, real[], row_vector)
+real exp_mod_normal_cdf_log(vector, row_vector, real[], real[])
+real exp_mod_normal_cdf_log(vector, real[], real, real)
+real exp_mod_normal_cdf_log(vector, real[], real, vector)
+real exp_mod_normal_cdf_log(vector, real[], real, row_vector)
+real exp_mod_normal_cdf_log(vector, real[], real, real[])
+real exp_mod_normal_cdf_log(vector, real[], vector, real)
+real exp_mod_normal_cdf_log(vector, real[], vector, vector)
+real exp_mod_normal_cdf_log(vector, real[], vector, row_vector)
+real exp_mod_normal_cdf_log(vector, real[], vector, real[])
+real exp_mod_normal_cdf_log(vector, real[], row_vector, real)
+real exp_mod_normal_cdf_log(vector, real[], row_vector, vector)
+real exp_mod_normal_cdf_log(vector, real[], row_vector, row_vector)
+real exp_mod_normal_cdf_log(vector, real[], row_vector, real[])
+real exp_mod_normal_cdf_log(vector, real[], real[], real)
+real exp_mod_normal_cdf_log(vector, real[], real[], vector)
+real exp_mod_normal_cdf_log(vector, real[], real[], row_vector)
+real exp_mod_normal_cdf_log(vector, real[], real[], real[])
+real exp_mod_normal_cdf_log(row_vector, real, real, real)
+real exp_mod_normal_cdf_log(row_vector, real, real, vector)
+real exp_mod_normal_cdf_log(row_vector, real, real, row_vector)
+real exp_mod_normal_cdf_log(row_vector, real, real, real[])
+real exp_mod_normal_cdf_log(row_vector, real, vector, real)
+real exp_mod_normal_cdf_log(row_vector, real, vector, vector)
+real exp_mod_normal_cdf_log(row_vector, real, vector, row_vector)
+real exp_mod_normal_cdf_log(row_vector, real, vector, real[])
+real exp_mod_normal_cdf_log(row_vector, real, row_vector, real)
+real exp_mod_normal_cdf_log(row_vector, real, row_vector, vector)
+real exp_mod_normal_cdf_log(row_vector, real, row_vector, row_vector)
+real exp_mod_normal_cdf_log(row_vector, real, row_vector, real[])
+real exp_mod_normal_cdf_log(row_vector, real, real[], real)
+real exp_mod_normal_cdf_log(row_vector, real, real[], vector)
+real exp_mod_normal_cdf_log(row_vector, real, real[], row_vector)
+real exp_mod_normal_cdf_log(row_vector, real, real[], real[])
+real exp_mod_normal_cdf_log(row_vector, vector, real, real)
+real exp_mod_normal_cdf_log(row_vector, vector, real, vector)
+real exp_mod_normal_cdf_log(row_vector, vector, real, row_vector)
+real exp_mod_normal_cdf_log(row_vector, vector, real, real[])
+real exp_mod_normal_cdf_log(row_vector, vector, vector, real)
+real exp_mod_normal_cdf_log(row_vector, vector, vector, vector)
+real exp_mod_normal_cdf_log(row_vector, vector, vector, row_vector)
+real exp_mod_normal_cdf_log(row_vector, vector, vector, real[])
+real exp_mod_normal_cdf_log(row_vector, vector, row_vector, real)
+real exp_mod_normal_cdf_log(row_vector, vector, row_vector, vector)
+real exp_mod_normal_cdf_log(row_vector, vector, row_vector, row_vector)
+real exp_mod_normal_cdf_log(row_vector, vector, row_vector, real[])
+real exp_mod_normal_cdf_log(row_vector, vector, real[], real)
+real exp_mod_normal_cdf_log(row_vector, vector, real[], vector)
+real exp_mod_normal_cdf_log(row_vector, vector, real[], row_vector)
+real exp_mod_normal_cdf_log(row_vector, vector, real[], real[])
+real exp_mod_normal_cdf_log(row_vector, row_vector, real, real)
+real exp_mod_normal_cdf_log(row_vector, row_vector, real, vector)
+real exp_mod_normal_cdf_log(row_vector, row_vector, real, row_vector)
+real exp_mod_normal_cdf_log(row_vector, row_vector, real, real[])
+real exp_mod_normal_cdf_log(row_vector, row_vector, vector, real)
+real exp_mod_normal_cdf_log(row_vector, row_vector, vector, vector)
+real exp_mod_normal_cdf_log(row_vector, row_vector, vector, row_vector)
+real exp_mod_normal_cdf_log(row_vector, row_vector, vector, real[])
+real exp_mod_normal_cdf_log(row_vector, row_vector, row_vector, real)
+real exp_mod_normal_cdf_log(row_vector, row_vector, row_vector, vector)
+real exp_mod_normal_cdf_log(row_vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_cdf_log(row_vector, row_vector, row_vector, real[])
+real exp_mod_normal_cdf_log(row_vector, row_vector, real[], real)
+real exp_mod_normal_cdf_log(row_vector, row_vector, real[], vector)
+real exp_mod_normal_cdf_log(row_vector, row_vector, real[], row_vector)
+real exp_mod_normal_cdf_log(row_vector, row_vector, real[], real[])
+real exp_mod_normal_cdf_log(row_vector, real[], real, real)
+real exp_mod_normal_cdf_log(row_vector, real[], real, vector)
+real exp_mod_normal_cdf_log(row_vector, real[], real, row_vector)
+real exp_mod_normal_cdf_log(row_vector, real[], real, real[])
+real exp_mod_normal_cdf_log(row_vector, real[], vector, real)
+real exp_mod_normal_cdf_log(row_vector, real[], vector, vector)
+real exp_mod_normal_cdf_log(row_vector, real[], vector, row_vector)
+real exp_mod_normal_cdf_log(row_vector, real[], vector, real[])
+real exp_mod_normal_cdf_log(row_vector, real[], row_vector, real)
+real exp_mod_normal_cdf_log(row_vector, real[], row_vector, vector)
+real exp_mod_normal_cdf_log(row_vector, real[], row_vector, row_vector)
+real exp_mod_normal_cdf_log(row_vector, real[], row_vector, real[])
+real exp_mod_normal_cdf_log(row_vector, real[], real[], real)
+real exp_mod_normal_cdf_log(row_vector, real[], real[], vector)
+real exp_mod_normal_cdf_log(row_vector, real[], real[], row_vector)
+real exp_mod_normal_cdf_log(row_vector, real[], real[], real[])
+real exp_mod_normal_cdf_log(real[], real, real, vector)
+real exp_mod_normal_cdf_log(real[], real, real, row_vector)
+real exp_mod_normal_cdf_log(real[], real, vector, real)
+real exp_mod_normal_cdf_log(real[], real, vector, vector)
+real exp_mod_normal_cdf_log(real[], real, vector, row_vector)
+real exp_mod_normal_cdf_log(real[], real, vector, real[])
+real exp_mod_normal_cdf_log(real[], real, row_vector, real)
+real exp_mod_normal_cdf_log(real[], real, row_vector, vector)
+real exp_mod_normal_cdf_log(real[], real, row_vector, row_vector)
+real exp_mod_normal_cdf_log(real[], real, row_vector, real[])
+real exp_mod_normal_cdf_log(real[], real, real[], vector)
+real exp_mod_normal_cdf_log(real[], real, real[], row_vector)
+real exp_mod_normal_cdf_log(real[], vector, real, real)
+real exp_mod_normal_cdf_log(real[], vector, real, vector)
+real exp_mod_normal_cdf_log(real[], vector, real, row_vector)
+real exp_mod_normal_cdf_log(real[], vector, real, real[])
+real exp_mod_normal_cdf_log(real[], vector, vector, real)
+real exp_mod_normal_cdf_log(real[], vector, vector, vector)
+real exp_mod_normal_cdf_log(real[], vector, vector, row_vector)
+real exp_mod_normal_cdf_log(real[], vector, vector, real[])
+real exp_mod_normal_cdf_log(real[], vector, row_vector, real)
+real exp_mod_normal_cdf_log(real[], vector, row_vector, vector)
+real exp_mod_normal_cdf_log(real[], vector, row_vector, row_vector)
+real exp_mod_normal_cdf_log(real[], vector, row_vector, real[])
+real exp_mod_normal_cdf_log(real[], vector, real[], real)
+real exp_mod_normal_cdf_log(real[], vector, real[], vector)
+real exp_mod_normal_cdf_log(real[], vector, real[], row_vector)
+real exp_mod_normal_cdf_log(real[], vector, real[], real[])
+real exp_mod_normal_cdf_log(real[], row_vector, real, real)
+real exp_mod_normal_cdf_log(real[], row_vector, real, vector)
+real exp_mod_normal_cdf_log(real[], row_vector, real, row_vector)
+real exp_mod_normal_cdf_log(real[], row_vector, real, real[])
+real exp_mod_normal_cdf_log(real[], row_vector, vector, real)
+real exp_mod_normal_cdf_log(real[], row_vector, vector, vector)
+real exp_mod_normal_cdf_log(real[], row_vector, vector, row_vector)
+real exp_mod_normal_cdf_log(real[], row_vector, vector, real[])
+real exp_mod_normal_cdf_log(real[], row_vector, row_vector, real)
+real exp_mod_normal_cdf_log(real[], row_vector, row_vector, vector)
+real exp_mod_normal_cdf_log(real[], row_vector, row_vector, row_vector)
+real exp_mod_normal_cdf_log(real[], row_vector, row_vector, real[])
+real exp_mod_normal_cdf_log(real[], row_vector, real[], real)
+real exp_mod_normal_cdf_log(real[], row_vector, real[], vector)
+real exp_mod_normal_cdf_log(real[], row_vector, real[], row_vector)
+real exp_mod_normal_cdf_log(real[], row_vector, real[], real[])
+real exp_mod_normal_cdf_log(real[], real[], real, vector)
+real exp_mod_normal_cdf_log(real[], real[], real, row_vector)
+real exp_mod_normal_cdf_log(real[], real[], vector, real)
+real exp_mod_normal_cdf_log(real[], real[], vector, vector)
+real exp_mod_normal_cdf_log(real[], real[], vector, row_vector)
+real exp_mod_normal_cdf_log(real[], real[], vector, real[])
+real exp_mod_normal_cdf_log(real[], real[], row_vector, real)
+real exp_mod_normal_cdf_log(real[], real[], row_vector, vector)
+real exp_mod_normal_cdf_log(real[], real[], row_vector, row_vector)
+real exp_mod_normal_cdf_log(real[], real[], row_vector, real[])
+real exp_mod_normal_cdf_log(real[], real[], real[], vector)
+real exp_mod_normal_cdf_log(real[], real[], real[], row_vector)
+real exp_mod_normal_lccdf(real, real, real, vector)
+real exp_mod_normal_lccdf(real, real, real, row_vector)
+real exp_mod_normal_lccdf(real, real, vector, real)
+real exp_mod_normal_lccdf(real, real, vector, vector)
+real exp_mod_normal_lccdf(real, real, vector, row_vector)
+real exp_mod_normal_lccdf(real, real, vector, real[])
+real exp_mod_normal_lccdf(real, real, row_vector, real)
+real exp_mod_normal_lccdf(real, real, row_vector, vector)
+real exp_mod_normal_lccdf(real, real, row_vector, row_vector)
+real exp_mod_normal_lccdf(real, real, row_vector, real[])
+real exp_mod_normal_lccdf(real, real, real[], vector)
+real exp_mod_normal_lccdf(real, real, real[], row_vector)
+real exp_mod_normal_lccdf(real, vector, real, real)
+real exp_mod_normal_lccdf(real, vector, real, vector)
+real exp_mod_normal_lccdf(real, vector, real, row_vector)
+real exp_mod_normal_lccdf(real, vector, real, real[])
+real exp_mod_normal_lccdf(real, vector, vector, real)
+real exp_mod_normal_lccdf(real, vector, vector, vector)
+real exp_mod_normal_lccdf(real, vector, vector, row_vector)
+real exp_mod_normal_lccdf(real, vector, vector, real[])
+real exp_mod_normal_lccdf(real, vector, row_vector, real)
+real exp_mod_normal_lccdf(real, vector, row_vector, vector)
+real exp_mod_normal_lccdf(real, vector, row_vector, row_vector)
+real exp_mod_normal_lccdf(real, vector, row_vector, real[])
+real exp_mod_normal_lccdf(real, vector, real[], real)
+real exp_mod_normal_lccdf(real, vector, real[], vector)
+real exp_mod_normal_lccdf(real, vector, real[], row_vector)
+real exp_mod_normal_lccdf(real, vector, real[], real[])
+real exp_mod_normal_lccdf(real, row_vector, real, real)
+real exp_mod_normal_lccdf(real, row_vector, real, vector)
+real exp_mod_normal_lccdf(real, row_vector, real, row_vector)
+real exp_mod_normal_lccdf(real, row_vector, real, real[])
+real exp_mod_normal_lccdf(real, row_vector, vector, real)
+real exp_mod_normal_lccdf(real, row_vector, vector, vector)
+real exp_mod_normal_lccdf(real, row_vector, vector, row_vector)
+real exp_mod_normal_lccdf(real, row_vector, vector, real[])
+real exp_mod_normal_lccdf(real, row_vector, row_vector, real)
+real exp_mod_normal_lccdf(real, row_vector, row_vector, vector)
+real exp_mod_normal_lccdf(real, row_vector, row_vector, row_vector)
+real exp_mod_normal_lccdf(real, row_vector, row_vector, real[])
+real exp_mod_normal_lccdf(real, row_vector, real[], real)
+real exp_mod_normal_lccdf(real, row_vector, real[], vector)
+real exp_mod_normal_lccdf(real, row_vector, real[], row_vector)
+real exp_mod_normal_lccdf(real, row_vector, real[], real[])
+real exp_mod_normal_lccdf(real, real[], real, vector)
+real exp_mod_normal_lccdf(real, real[], real, row_vector)
+real exp_mod_normal_lccdf(real, real[], vector, real)
+real exp_mod_normal_lccdf(real, real[], vector, vector)
+real exp_mod_normal_lccdf(real, real[], vector, row_vector)
+real exp_mod_normal_lccdf(real, real[], vector, real[])
+real exp_mod_normal_lccdf(real, real[], row_vector, real)
+real exp_mod_normal_lccdf(real, real[], row_vector, vector)
+real exp_mod_normal_lccdf(real, real[], row_vector, row_vector)
+real exp_mod_normal_lccdf(real, real[], row_vector, real[])
+real exp_mod_normal_lccdf(real, real[], real[], vector)
+real exp_mod_normal_lccdf(real, real[], real[], row_vector)
+real exp_mod_normal_lccdf(vector, real, real, real)
+real exp_mod_normal_lccdf(vector, real, real, vector)
+real exp_mod_normal_lccdf(vector, real, real, row_vector)
+real exp_mod_normal_lccdf(vector, real, real, real[])
+real exp_mod_normal_lccdf(vector, real, vector, real)
+real exp_mod_normal_lccdf(vector, real, vector, vector)
+real exp_mod_normal_lccdf(vector, real, vector, row_vector)
+real exp_mod_normal_lccdf(vector, real, vector, real[])
+real exp_mod_normal_lccdf(vector, real, row_vector, real)
+real exp_mod_normal_lccdf(vector, real, row_vector, vector)
+real exp_mod_normal_lccdf(vector, real, row_vector, row_vector)
+real exp_mod_normal_lccdf(vector, real, row_vector, real[])
+real exp_mod_normal_lccdf(vector, real, real[], real)
+real exp_mod_normal_lccdf(vector, real, real[], vector)
+real exp_mod_normal_lccdf(vector, real, real[], row_vector)
+real exp_mod_normal_lccdf(vector, real, real[], real[])
+real exp_mod_normal_lccdf(vector, vector, real, real)
+real exp_mod_normal_lccdf(vector, vector, real, vector)
+real exp_mod_normal_lccdf(vector, vector, real, row_vector)
+real exp_mod_normal_lccdf(vector, vector, real, real[])
+real exp_mod_normal_lccdf(vector, vector, vector, real)
+real exp_mod_normal_lccdf(vector, vector, vector, vector)
+real exp_mod_normal_lccdf(vector, vector, vector, row_vector)
+real exp_mod_normal_lccdf(vector, vector, vector, real[])
+real exp_mod_normal_lccdf(vector, vector, row_vector, real)
+real exp_mod_normal_lccdf(vector, vector, row_vector, vector)
+real exp_mod_normal_lccdf(vector, vector, row_vector, row_vector)
+real exp_mod_normal_lccdf(vector, vector, row_vector, real[])
+real exp_mod_normal_lccdf(vector, vector, real[], real)
+real exp_mod_normal_lccdf(vector, vector, real[], vector)
+real exp_mod_normal_lccdf(vector, vector, real[], row_vector)
+real exp_mod_normal_lccdf(vector, vector, real[], real[])
+real exp_mod_normal_lccdf(vector, row_vector, real, real)
+real exp_mod_normal_lccdf(vector, row_vector, real, vector)
+real exp_mod_normal_lccdf(vector, row_vector, real, row_vector)
+real exp_mod_normal_lccdf(vector, row_vector, real, real[])
+real exp_mod_normal_lccdf(vector, row_vector, vector, real)
+real exp_mod_normal_lccdf(vector, row_vector, vector, vector)
+real exp_mod_normal_lccdf(vector, row_vector, vector, row_vector)
+real exp_mod_normal_lccdf(vector, row_vector, vector, real[])
+real exp_mod_normal_lccdf(vector, row_vector, row_vector, real)
+real exp_mod_normal_lccdf(vector, row_vector, row_vector, vector)
+real exp_mod_normal_lccdf(vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_lccdf(vector, row_vector, row_vector, real[])
+real exp_mod_normal_lccdf(vector, row_vector, real[], real)
+real exp_mod_normal_lccdf(vector, row_vector, real[], vector)
+real exp_mod_normal_lccdf(vector, row_vector, real[], row_vector)
+real exp_mod_normal_lccdf(vector, row_vector, real[], real[])
+real exp_mod_normal_lccdf(vector, real[], real, real)
+real exp_mod_normal_lccdf(vector, real[], real, vector)
+real exp_mod_normal_lccdf(vector, real[], real, row_vector)
+real exp_mod_normal_lccdf(vector, real[], real, real[])
+real exp_mod_normal_lccdf(vector, real[], vector, real)
+real exp_mod_normal_lccdf(vector, real[], vector, vector)
+real exp_mod_normal_lccdf(vector, real[], vector, row_vector)
+real exp_mod_normal_lccdf(vector, real[], vector, real[])
+real exp_mod_normal_lccdf(vector, real[], row_vector, real)
+real exp_mod_normal_lccdf(vector, real[], row_vector, vector)
+real exp_mod_normal_lccdf(vector, real[], row_vector, row_vector)
+real exp_mod_normal_lccdf(vector, real[], row_vector, real[])
+real exp_mod_normal_lccdf(vector, real[], real[], real)
+real exp_mod_normal_lccdf(vector, real[], real[], vector)
+real exp_mod_normal_lccdf(vector, real[], real[], row_vector)
+real exp_mod_normal_lccdf(vector, real[], real[], real[])
+real exp_mod_normal_lccdf(row_vector, real, real, real)
+real exp_mod_normal_lccdf(row_vector, real, real, vector)
+real exp_mod_normal_lccdf(row_vector, real, real, row_vector)
+real exp_mod_normal_lccdf(row_vector, real, real, real[])
+real exp_mod_normal_lccdf(row_vector, real, vector, real)
+real exp_mod_normal_lccdf(row_vector, real, vector, vector)
+real exp_mod_normal_lccdf(row_vector, real, vector, row_vector)
+real exp_mod_normal_lccdf(row_vector, real, vector, real[])
+real exp_mod_normal_lccdf(row_vector, real, row_vector, real)
+real exp_mod_normal_lccdf(row_vector, real, row_vector, vector)
+real exp_mod_normal_lccdf(row_vector, real, row_vector, row_vector)
+real exp_mod_normal_lccdf(row_vector, real, row_vector, real[])
+real exp_mod_normal_lccdf(row_vector, real, real[], real)
+real exp_mod_normal_lccdf(row_vector, real, real[], vector)
+real exp_mod_normal_lccdf(row_vector, real, real[], row_vector)
+real exp_mod_normal_lccdf(row_vector, real, real[], real[])
+real exp_mod_normal_lccdf(row_vector, vector, real, real)
+real exp_mod_normal_lccdf(row_vector, vector, real, vector)
+real exp_mod_normal_lccdf(row_vector, vector, real, row_vector)
+real exp_mod_normal_lccdf(row_vector, vector, real, real[])
+real exp_mod_normal_lccdf(row_vector, vector, vector, real)
+real exp_mod_normal_lccdf(row_vector, vector, vector, vector)
+real exp_mod_normal_lccdf(row_vector, vector, vector, row_vector)
+real exp_mod_normal_lccdf(row_vector, vector, vector, real[])
+real exp_mod_normal_lccdf(row_vector, vector, row_vector, real)
+real exp_mod_normal_lccdf(row_vector, vector, row_vector, vector)
+real exp_mod_normal_lccdf(row_vector, vector, row_vector, row_vector)
+real exp_mod_normal_lccdf(row_vector, vector, row_vector, real[])
+real exp_mod_normal_lccdf(row_vector, vector, real[], real)
+real exp_mod_normal_lccdf(row_vector, vector, real[], vector)
+real exp_mod_normal_lccdf(row_vector, vector, real[], row_vector)
+real exp_mod_normal_lccdf(row_vector, vector, real[], real[])
+real exp_mod_normal_lccdf(row_vector, row_vector, real, real)
+real exp_mod_normal_lccdf(row_vector, row_vector, real, vector)
+real exp_mod_normal_lccdf(row_vector, row_vector, real, row_vector)
+real exp_mod_normal_lccdf(row_vector, row_vector, real, real[])
+real exp_mod_normal_lccdf(row_vector, row_vector, vector, real)
+real exp_mod_normal_lccdf(row_vector, row_vector, vector, vector)
+real exp_mod_normal_lccdf(row_vector, row_vector, vector, row_vector)
+real exp_mod_normal_lccdf(row_vector, row_vector, vector, real[])
+real exp_mod_normal_lccdf(row_vector, row_vector, row_vector, real)
+real exp_mod_normal_lccdf(row_vector, row_vector, row_vector, vector)
+real exp_mod_normal_lccdf(row_vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_lccdf(row_vector, row_vector, row_vector, real[])
+real exp_mod_normal_lccdf(row_vector, row_vector, real[], real)
+real exp_mod_normal_lccdf(row_vector, row_vector, real[], vector)
+real exp_mod_normal_lccdf(row_vector, row_vector, real[], row_vector)
+real exp_mod_normal_lccdf(row_vector, row_vector, real[], real[])
+real exp_mod_normal_lccdf(row_vector, real[], real, real)
+real exp_mod_normal_lccdf(row_vector, real[], real, vector)
+real exp_mod_normal_lccdf(row_vector, real[], real, row_vector)
+real exp_mod_normal_lccdf(row_vector, real[], real, real[])
+real exp_mod_normal_lccdf(row_vector, real[], vector, real)
+real exp_mod_normal_lccdf(row_vector, real[], vector, vector)
+real exp_mod_normal_lccdf(row_vector, real[], vector, row_vector)
+real exp_mod_normal_lccdf(row_vector, real[], vector, real[])
+real exp_mod_normal_lccdf(row_vector, real[], row_vector, real)
+real exp_mod_normal_lccdf(row_vector, real[], row_vector, vector)
+real exp_mod_normal_lccdf(row_vector, real[], row_vector, row_vector)
+real exp_mod_normal_lccdf(row_vector, real[], row_vector, real[])
+real exp_mod_normal_lccdf(row_vector, real[], real[], real)
+real exp_mod_normal_lccdf(row_vector, real[], real[], vector)
+real exp_mod_normal_lccdf(row_vector, real[], real[], row_vector)
+real exp_mod_normal_lccdf(row_vector, real[], real[], real[])
+real exp_mod_normal_lccdf(real[], real, real, vector)
+real exp_mod_normal_lccdf(real[], real, real, row_vector)
+real exp_mod_normal_lccdf(real[], real, vector, real)
+real exp_mod_normal_lccdf(real[], real, vector, vector)
+real exp_mod_normal_lccdf(real[], real, vector, row_vector)
+real exp_mod_normal_lccdf(real[], real, vector, real[])
+real exp_mod_normal_lccdf(real[], real, row_vector, real)
+real exp_mod_normal_lccdf(real[], real, row_vector, vector)
+real exp_mod_normal_lccdf(real[], real, row_vector, row_vector)
+real exp_mod_normal_lccdf(real[], real, row_vector, real[])
+real exp_mod_normal_lccdf(real[], real, real[], vector)
+real exp_mod_normal_lccdf(real[], real, real[], row_vector)
+real exp_mod_normal_lccdf(real[], vector, real, real)
+real exp_mod_normal_lccdf(real[], vector, real, vector)
+real exp_mod_normal_lccdf(real[], vector, real, row_vector)
+real exp_mod_normal_lccdf(real[], vector, real, real[])
+real exp_mod_normal_lccdf(real[], vector, vector, real)
+real exp_mod_normal_lccdf(real[], vector, vector, vector)
+real exp_mod_normal_lccdf(real[], vector, vector, row_vector)
+real exp_mod_normal_lccdf(real[], vector, vector, real[])
+real exp_mod_normal_lccdf(real[], vector, row_vector, real)
+real exp_mod_normal_lccdf(real[], vector, row_vector, vector)
+real exp_mod_normal_lccdf(real[], vector, row_vector, row_vector)
+real exp_mod_normal_lccdf(real[], vector, row_vector, real[])
+real exp_mod_normal_lccdf(real[], vector, real[], real)
+real exp_mod_normal_lccdf(real[], vector, real[], vector)
+real exp_mod_normal_lccdf(real[], vector, real[], row_vector)
+real exp_mod_normal_lccdf(real[], vector, real[], real[])
+real exp_mod_normal_lccdf(real[], row_vector, real, real)
+real exp_mod_normal_lccdf(real[], row_vector, real, vector)
+real exp_mod_normal_lccdf(real[], row_vector, real, row_vector)
+real exp_mod_normal_lccdf(real[], row_vector, real, real[])
+real exp_mod_normal_lccdf(real[], row_vector, vector, real)
+real exp_mod_normal_lccdf(real[], row_vector, vector, vector)
+real exp_mod_normal_lccdf(real[], row_vector, vector, row_vector)
+real exp_mod_normal_lccdf(real[], row_vector, vector, real[])
+real exp_mod_normal_lccdf(real[], row_vector, row_vector, real)
+real exp_mod_normal_lccdf(real[], row_vector, row_vector, vector)
+real exp_mod_normal_lccdf(real[], row_vector, row_vector, row_vector)
+real exp_mod_normal_lccdf(real[], row_vector, row_vector, real[])
+real exp_mod_normal_lccdf(real[], row_vector, real[], real)
+real exp_mod_normal_lccdf(real[], row_vector, real[], vector)
+real exp_mod_normal_lccdf(real[], row_vector, real[], row_vector)
+real exp_mod_normal_lccdf(real[], row_vector, real[], real[])
+real exp_mod_normal_lccdf(real[], real[], real, vector)
+real exp_mod_normal_lccdf(real[], real[], real, row_vector)
+real exp_mod_normal_lccdf(real[], real[], vector, real)
+real exp_mod_normal_lccdf(real[], real[], vector, vector)
+real exp_mod_normal_lccdf(real[], real[], vector, row_vector)
+real exp_mod_normal_lccdf(real[], real[], vector, real[])
+real exp_mod_normal_lccdf(real[], real[], row_vector, real)
+real exp_mod_normal_lccdf(real[], real[], row_vector, vector)
+real exp_mod_normal_lccdf(real[], real[], row_vector, row_vector)
+real exp_mod_normal_lccdf(real[], real[], row_vector, real[])
+real exp_mod_normal_lccdf(real[], real[], real[], vector)
+real exp_mod_normal_lccdf(real[], real[], real[], row_vector)
+real exp_mod_normal_lcdf(real, real, real, vector)
+real exp_mod_normal_lcdf(real, real, real, row_vector)
+real exp_mod_normal_lcdf(real, real, vector, real)
+real exp_mod_normal_lcdf(real, real, vector, vector)
+real exp_mod_normal_lcdf(real, real, vector, row_vector)
+real exp_mod_normal_lcdf(real, real, vector, real[])
+real exp_mod_normal_lcdf(real, real, row_vector, real)
+real exp_mod_normal_lcdf(real, real, row_vector, vector)
+real exp_mod_normal_lcdf(real, real, row_vector, row_vector)
+real exp_mod_normal_lcdf(real, real, row_vector, real[])
+real exp_mod_normal_lcdf(real, real, real[], vector)
+real exp_mod_normal_lcdf(real, real, real[], row_vector)
+real exp_mod_normal_lcdf(real, vector, real, real)
+real exp_mod_normal_lcdf(real, vector, real, vector)
+real exp_mod_normal_lcdf(real, vector, real, row_vector)
+real exp_mod_normal_lcdf(real, vector, real, real[])
+real exp_mod_normal_lcdf(real, vector, vector, real)
+real exp_mod_normal_lcdf(real, vector, vector, vector)
+real exp_mod_normal_lcdf(real, vector, vector, row_vector)
+real exp_mod_normal_lcdf(real, vector, vector, real[])
+real exp_mod_normal_lcdf(real, vector, row_vector, real)
+real exp_mod_normal_lcdf(real, vector, row_vector, vector)
+real exp_mod_normal_lcdf(real, vector, row_vector, row_vector)
+real exp_mod_normal_lcdf(real, vector, row_vector, real[])
+real exp_mod_normal_lcdf(real, vector, real[], real)
+real exp_mod_normal_lcdf(real, vector, real[], vector)
+real exp_mod_normal_lcdf(real, vector, real[], row_vector)
+real exp_mod_normal_lcdf(real, vector, real[], real[])
+real exp_mod_normal_lcdf(real, row_vector, real, real)
+real exp_mod_normal_lcdf(real, row_vector, real, vector)
+real exp_mod_normal_lcdf(real, row_vector, real, row_vector)
+real exp_mod_normal_lcdf(real, row_vector, real, real[])
+real exp_mod_normal_lcdf(real, row_vector, vector, real)
+real exp_mod_normal_lcdf(real, row_vector, vector, vector)
+real exp_mod_normal_lcdf(real, row_vector, vector, row_vector)
+real exp_mod_normal_lcdf(real, row_vector, vector, real[])
+real exp_mod_normal_lcdf(real, row_vector, row_vector, real)
+real exp_mod_normal_lcdf(real, row_vector, row_vector, vector)
+real exp_mod_normal_lcdf(real, row_vector, row_vector, row_vector)
+real exp_mod_normal_lcdf(real, row_vector, row_vector, real[])
+real exp_mod_normal_lcdf(real, row_vector, real[], real)
+real exp_mod_normal_lcdf(real, row_vector, real[], vector)
+real exp_mod_normal_lcdf(real, row_vector, real[], row_vector)
+real exp_mod_normal_lcdf(real, row_vector, real[], real[])
+real exp_mod_normal_lcdf(real, real[], real, vector)
+real exp_mod_normal_lcdf(real, real[], real, row_vector)
+real exp_mod_normal_lcdf(real, real[], vector, real)
+real exp_mod_normal_lcdf(real, real[], vector, vector)
+real exp_mod_normal_lcdf(real, real[], vector, row_vector)
+real exp_mod_normal_lcdf(real, real[], vector, real[])
+real exp_mod_normal_lcdf(real, real[], row_vector, real)
+real exp_mod_normal_lcdf(real, real[], row_vector, vector)
+real exp_mod_normal_lcdf(real, real[], row_vector, row_vector)
+real exp_mod_normal_lcdf(real, real[], row_vector, real[])
+real exp_mod_normal_lcdf(real, real[], real[], vector)
+real exp_mod_normal_lcdf(real, real[], real[], row_vector)
+real exp_mod_normal_lcdf(vector, real, real, real)
+real exp_mod_normal_lcdf(vector, real, real, vector)
+real exp_mod_normal_lcdf(vector, real, real, row_vector)
+real exp_mod_normal_lcdf(vector, real, real, real[])
+real exp_mod_normal_lcdf(vector, real, vector, real)
+real exp_mod_normal_lcdf(vector, real, vector, vector)
+real exp_mod_normal_lcdf(vector, real, vector, row_vector)
+real exp_mod_normal_lcdf(vector, real, vector, real[])
+real exp_mod_normal_lcdf(vector, real, row_vector, real)
+real exp_mod_normal_lcdf(vector, real, row_vector, vector)
+real exp_mod_normal_lcdf(vector, real, row_vector, row_vector)
+real exp_mod_normal_lcdf(vector, real, row_vector, real[])
+real exp_mod_normal_lcdf(vector, real, real[], real)
+real exp_mod_normal_lcdf(vector, real, real[], vector)
+real exp_mod_normal_lcdf(vector, real, real[], row_vector)
+real exp_mod_normal_lcdf(vector, real, real[], real[])
+real exp_mod_normal_lcdf(vector, vector, real, real)
+real exp_mod_normal_lcdf(vector, vector, real, vector)
+real exp_mod_normal_lcdf(vector, vector, real, row_vector)
+real exp_mod_normal_lcdf(vector, vector, real, real[])
+real exp_mod_normal_lcdf(vector, vector, vector, real)
+real exp_mod_normal_lcdf(vector, vector, vector, vector)
+real exp_mod_normal_lcdf(vector, vector, vector, row_vector)
+real exp_mod_normal_lcdf(vector, vector, vector, real[])
+real exp_mod_normal_lcdf(vector, vector, row_vector, real)
+real exp_mod_normal_lcdf(vector, vector, row_vector, vector)
+real exp_mod_normal_lcdf(vector, vector, row_vector, row_vector)
+real exp_mod_normal_lcdf(vector, vector, row_vector, real[])
+real exp_mod_normal_lcdf(vector, vector, real[], real)
+real exp_mod_normal_lcdf(vector, vector, real[], vector)
+real exp_mod_normal_lcdf(vector, vector, real[], row_vector)
+real exp_mod_normal_lcdf(vector, vector, real[], real[])
+real exp_mod_normal_lcdf(vector, row_vector, real, real)
+real exp_mod_normal_lcdf(vector, row_vector, real, vector)
+real exp_mod_normal_lcdf(vector, row_vector, real, row_vector)
+real exp_mod_normal_lcdf(vector, row_vector, real, real[])
+real exp_mod_normal_lcdf(vector, row_vector, vector, real)
+real exp_mod_normal_lcdf(vector, row_vector, vector, vector)
+real exp_mod_normal_lcdf(vector, row_vector, vector, row_vector)
+real exp_mod_normal_lcdf(vector, row_vector, vector, real[])
+real exp_mod_normal_lcdf(vector, row_vector, row_vector, real)
+real exp_mod_normal_lcdf(vector, row_vector, row_vector, vector)
+real exp_mod_normal_lcdf(vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_lcdf(vector, row_vector, row_vector, real[])
+real exp_mod_normal_lcdf(vector, row_vector, real[], real)
+real exp_mod_normal_lcdf(vector, row_vector, real[], vector)
+real exp_mod_normal_lcdf(vector, row_vector, real[], row_vector)
+real exp_mod_normal_lcdf(vector, row_vector, real[], real[])
+real exp_mod_normal_lcdf(vector, real[], real, real)
+real exp_mod_normal_lcdf(vector, real[], real, vector)
+real exp_mod_normal_lcdf(vector, real[], real, row_vector)
+real exp_mod_normal_lcdf(vector, real[], real, real[])
+real exp_mod_normal_lcdf(vector, real[], vector, real)
+real exp_mod_normal_lcdf(vector, real[], vector, vector)
+real exp_mod_normal_lcdf(vector, real[], vector, row_vector)
+real exp_mod_normal_lcdf(vector, real[], vector, real[])
+real exp_mod_normal_lcdf(vector, real[], row_vector, real)
+real exp_mod_normal_lcdf(vector, real[], row_vector, vector)
+real exp_mod_normal_lcdf(vector, real[], row_vector, row_vector)
+real exp_mod_normal_lcdf(vector, real[], row_vector, real[])
+real exp_mod_normal_lcdf(vector, real[], real[], real)
+real exp_mod_normal_lcdf(vector, real[], real[], vector)
+real exp_mod_normal_lcdf(vector, real[], real[], row_vector)
+real exp_mod_normal_lcdf(vector, real[], real[], real[])
+real exp_mod_normal_lcdf(row_vector, real, real, real)
+real exp_mod_normal_lcdf(row_vector, real, real, vector)
+real exp_mod_normal_lcdf(row_vector, real, real, row_vector)
+real exp_mod_normal_lcdf(row_vector, real, real, real[])
+real exp_mod_normal_lcdf(row_vector, real, vector, real)
+real exp_mod_normal_lcdf(row_vector, real, vector, vector)
+real exp_mod_normal_lcdf(row_vector, real, vector, row_vector)
+real exp_mod_normal_lcdf(row_vector, real, vector, real[])
+real exp_mod_normal_lcdf(row_vector, real, row_vector, real)
+real exp_mod_normal_lcdf(row_vector, real, row_vector, vector)
+real exp_mod_normal_lcdf(row_vector, real, row_vector, row_vector)
+real exp_mod_normal_lcdf(row_vector, real, row_vector, real[])
+real exp_mod_normal_lcdf(row_vector, real, real[], real)
+real exp_mod_normal_lcdf(row_vector, real, real[], vector)
+real exp_mod_normal_lcdf(row_vector, real, real[], row_vector)
+real exp_mod_normal_lcdf(row_vector, real, real[], real[])
+real exp_mod_normal_lcdf(row_vector, vector, real, real)
+real exp_mod_normal_lcdf(row_vector, vector, real, vector)
+real exp_mod_normal_lcdf(row_vector, vector, real, row_vector)
+real exp_mod_normal_lcdf(row_vector, vector, real, real[])
+real exp_mod_normal_lcdf(row_vector, vector, vector, real)
+real exp_mod_normal_lcdf(row_vector, vector, vector, vector)
+real exp_mod_normal_lcdf(row_vector, vector, vector, row_vector)
+real exp_mod_normal_lcdf(row_vector, vector, vector, real[])
+real exp_mod_normal_lcdf(row_vector, vector, row_vector, real)
+real exp_mod_normal_lcdf(row_vector, vector, row_vector, vector)
+real exp_mod_normal_lcdf(row_vector, vector, row_vector, row_vector)
+real exp_mod_normal_lcdf(row_vector, vector, row_vector, real[])
+real exp_mod_normal_lcdf(row_vector, vector, real[], real)
+real exp_mod_normal_lcdf(row_vector, vector, real[], vector)
+real exp_mod_normal_lcdf(row_vector, vector, real[], row_vector)
+real exp_mod_normal_lcdf(row_vector, vector, real[], real[])
+real exp_mod_normal_lcdf(row_vector, row_vector, real, real)
+real exp_mod_normal_lcdf(row_vector, row_vector, real, vector)
+real exp_mod_normal_lcdf(row_vector, row_vector, real, row_vector)
+real exp_mod_normal_lcdf(row_vector, row_vector, real, real[])
+real exp_mod_normal_lcdf(row_vector, row_vector, vector, real)
+real exp_mod_normal_lcdf(row_vector, row_vector, vector, vector)
+real exp_mod_normal_lcdf(row_vector, row_vector, vector, row_vector)
+real exp_mod_normal_lcdf(row_vector, row_vector, vector, real[])
+real exp_mod_normal_lcdf(row_vector, row_vector, row_vector, real)
+real exp_mod_normal_lcdf(row_vector, row_vector, row_vector, vector)
+real exp_mod_normal_lcdf(row_vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_lcdf(row_vector, row_vector, row_vector, real[])
+real exp_mod_normal_lcdf(row_vector, row_vector, real[], real)
+real exp_mod_normal_lcdf(row_vector, row_vector, real[], vector)
+real exp_mod_normal_lcdf(row_vector, row_vector, real[], row_vector)
+real exp_mod_normal_lcdf(row_vector, row_vector, real[], real[])
+real exp_mod_normal_lcdf(row_vector, real[], real, real)
+real exp_mod_normal_lcdf(row_vector, real[], real, vector)
+real exp_mod_normal_lcdf(row_vector, real[], real, row_vector)
+real exp_mod_normal_lcdf(row_vector, real[], real, real[])
+real exp_mod_normal_lcdf(row_vector, real[], vector, real)
+real exp_mod_normal_lcdf(row_vector, real[], vector, vector)
+real exp_mod_normal_lcdf(row_vector, real[], vector, row_vector)
+real exp_mod_normal_lcdf(row_vector, real[], vector, real[])
+real exp_mod_normal_lcdf(row_vector, real[], row_vector, real)
+real exp_mod_normal_lcdf(row_vector, real[], row_vector, vector)
+real exp_mod_normal_lcdf(row_vector, real[], row_vector, row_vector)
+real exp_mod_normal_lcdf(row_vector, real[], row_vector, real[])
+real exp_mod_normal_lcdf(row_vector, real[], real[], real)
+real exp_mod_normal_lcdf(row_vector, real[], real[], vector)
+real exp_mod_normal_lcdf(row_vector, real[], real[], row_vector)
+real exp_mod_normal_lcdf(row_vector, real[], real[], real[])
+real exp_mod_normal_lcdf(real[], real, real, vector)
+real exp_mod_normal_lcdf(real[], real, real, row_vector)
+real exp_mod_normal_lcdf(real[], real, vector, real)
+real exp_mod_normal_lcdf(real[], real, vector, vector)
+real exp_mod_normal_lcdf(real[], real, vector, row_vector)
+real exp_mod_normal_lcdf(real[], real, vector, real[])
+real exp_mod_normal_lcdf(real[], real, row_vector, real)
+real exp_mod_normal_lcdf(real[], real, row_vector, vector)
+real exp_mod_normal_lcdf(real[], real, row_vector, row_vector)
+real exp_mod_normal_lcdf(real[], real, row_vector, real[])
+real exp_mod_normal_lcdf(real[], real, real[], vector)
+real exp_mod_normal_lcdf(real[], real, real[], row_vector)
+real exp_mod_normal_lcdf(real[], real, real[], real[])
+real exp_mod_normal_lcdf(real[], vector, real, real)
+real exp_mod_normal_lcdf(real[], vector, real, vector)
+real exp_mod_normal_lcdf(real[], vector, real, row_vector)
+real exp_mod_normal_lcdf(real[], vector, real, real[])
+real exp_mod_normal_lcdf(real[], vector, vector, real)
+real exp_mod_normal_lcdf(real[], vector, vector, vector)
+real exp_mod_normal_lcdf(real[], vector, vector, row_vector)
+real exp_mod_normal_lcdf(real[], vector, vector, real[])
+real exp_mod_normal_lcdf(real[], vector, row_vector, real)
+real exp_mod_normal_lcdf(real[], vector, row_vector, vector)
+real exp_mod_normal_lcdf(real[], vector, row_vector, row_vector)
+real exp_mod_normal_lcdf(real[], vector, row_vector, real[])
+real exp_mod_normal_lcdf(real[], vector, real[], real)
+real exp_mod_normal_lcdf(real[], vector, real[], vector)
+real exp_mod_normal_lcdf(real[], vector, real[], row_vector)
+real exp_mod_normal_lcdf(real[], vector, real[], real[])
+real exp_mod_normal_lcdf(real[], row_vector, real, real)
+real exp_mod_normal_lcdf(real[], row_vector, real, vector)
+real exp_mod_normal_lcdf(real[], row_vector, real, row_vector)
+real exp_mod_normal_lcdf(real[], row_vector, real, real[])
+real exp_mod_normal_lcdf(real[], row_vector, vector, real)
+real exp_mod_normal_lcdf(real[], row_vector, vector, vector)
+real exp_mod_normal_lcdf(real[], row_vector, vector, row_vector)
+real exp_mod_normal_lcdf(real[], row_vector, vector, real[])
+real exp_mod_normal_lcdf(real[], row_vector, row_vector, real)
+real exp_mod_normal_lcdf(real[], row_vector, row_vector, vector)
+real exp_mod_normal_lcdf(real[], row_vector, row_vector, row_vector)
+real exp_mod_normal_lcdf(real[], row_vector, row_vector, real[])
+real exp_mod_normal_lcdf(real[], row_vector, real[], real)
+real exp_mod_normal_lcdf(real[], row_vector, real[], vector)
+real exp_mod_normal_lcdf(real[], row_vector, real[], row_vector)
+real exp_mod_normal_lcdf(real[], row_vector, real[], real[])
+real exp_mod_normal_lcdf(real[], real[], real, vector)
+real exp_mod_normal_lcdf(real[], real[], real, row_vector)
+real exp_mod_normal_lcdf(real[], real[], vector, real)
+real exp_mod_normal_lcdf(real[], real[], vector, vector)
+real exp_mod_normal_lcdf(real[], real[], vector, row_vector)
+real exp_mod_normal_lcdf(real[], real[], vector, real[])
+real exp_mod_normal_lcdf(real[], real[], row_vector, real)
+real exp_mod_normal_lcdf(real[], real[], row_vector, vector)
+real exp_mod_normal_lcdf(real[], real[], row_vector, row_vector)
+real exp_mod_normal_lcdf(real[], real[], row_vector, real[])
+real exp_mod_normal_lcdf(real[], real[], real[], vector)
+real exp_mod_normal_lcdf(real[], real[], real[], row_vector)
+real exp_mod_normal_log(real, real, real, vector)
+real exp_mod_normal_log(real, real, real, row_vector)
+real exp_mod_normal_log(real, real, vector, real)
+real exp_mod_normal_log(real, real, vector, vector)
+real exp_mod_normal_log(real, real, vector, row_vector)
+real exp_mod_normal_log(real, real, vector, real[])
+real exp_mod_normal_log(real, real, row_vector, real)
+real exp_mod_normal_log(real, real, row_vector, vector)
+real exp_mod_normal_log(real, real, row_vector, row_vector)
+real exp_mod_normal_log(real, real, row_vector, real[])
+real exp_mod_normal_log(real, real, real[], vector)
+real exp_mod_normal_log(real, real, real[], row_vector)
+real exp_mod_normal_log(real, vector, real, real)
+real exp_mod_normal_log(real, vector, real, vector)
+real exp_mod_normal_log(real, vector, real, row_vector)
+real exp_mod_normal_log(real, vector, real, real[])
+real exp_mod_normal_log(real, vector, vector, real)
+real exp_mod_normal_log(real, vector, vector, vector)
+real exp_mod_normal_log(real, vector, vector, row_vector)
+real exp_mod_normal_log(real, vector, vector, real[])
+real exp_mod_normal_log(real, vector, row_vector, real)
+real exp_mod_normal_log(real, vector, row_vector, vector)
+real exp_mod_normal_log(real, vector, row_vector, row_vector)
+real exp_mod_normal_log(real, vector, row_vector, real[])
+real exp_mod_normal_log(real, vector, real[], real)
+real exp_mod_normal_log(real, vector, real[], vector)
+real exp_mod_normal_log(real, vector, real[], row_vector)
+real exp_mod_normal_log(real, vector, real[], real[])
+real exp_mod_normal_log(real, row_vector, real, real)
+real exp_mod_normal_log(real, row_vector, real, vector)
+real exp_mod_normal_log(real, row_vector, real, row_vector)
+real exp_mod_normal_log(real, row_vector, real, real[])
+real exp_mod_normal_log(real, row_vector, vector, real)
+real exp_mod_normal_log(real, row_vector, vector, vector)
+real exp_mod_normal_log(real, row_vector, vector, row_vector)
+real exp_mod_normal_log(real, row_vector, vector, real[])
+real exp_mod_normal_log(real, row_vector, row_vector, real)
+real exp_mod_normal_log(real, row_vector, row_vector, vector)
+real exp_mod_normal_log(real, row_vector, row_vector, row_vector)
+real exp_mod_normal_log(real, row_vector, row_vector, real[])
+real exp_mod_normal_log(real, row_vector, real[], real)
+real exp_mod_normal_log(real, row_vector, real[], vector)
+real exp_mod_normal_log(real, row_vector, real[], row_vector)
+real exp_mod_normal_log(real, row_vector, real[], real[])
+real exp_mod_normal_log(real, real[], real, vector)
+real exp_mod_normal_log(real, real[], real, row_vector)
+real exp_mod_normal_log(real, real[], vector, real)
+real exp_mod_normal_log(real, real[], vector, vector)
+real exp_mod_normal_log(real, real[], vector, row_vector)
+real exp_mod_normal_log(real, real[], vector, real[])
+real exp_mod_normal_log(real, real[], row_vector, real)
+real exp_mod_normal_log(real, real[], row_vector, vector)
+real exp_mod_normal_log(real, real[], row_vector, row_vector)
+real exp_mod_normal_log(real, real[], row_vector, real[])
+real exp_mod_normal_log(real, real[], real[], vector)
+real exp_mod_normal_log(real, real[], real[], row_vector)
+real exp_mod_normal_log(vector, real, real, real)
+real exp_mod_normal_log(vector, real, real, vector)
+real exp_mod_normal_log(vector, real, real, row_vector)
+real exp_mod_normal_log(vector, real, real, real[])
+real exp_mod_normal_log(vector, real, vector, real)
+real exp_mod_normal_log(vector, real, vector, vector)
+real exp_mod_normal_log(vector, real, vector, row_vector)
+real exp_mod_normal_log(vector, real, vector, real[])
+real exp_mod_normal_log(vector, real, row_vector, real)
+real exp_mod_normal_log(vector, real, row_vector, vector)
+real exp_mod_normal_log(vector, real, row_vector, row_vector)
+real exp_mod_normal_log(vector, real, row_vector, real[])
+real exp_mod_normal_log(vector, real, real[], real)
+real exp_mod_normal_log(vector, real, real[], vector)
+real exp_mod_normal_log(vector, real, real[], row_vector)
+real exp_mod_normal_log(vector, real, real[], real[])
+real exp_mod_normal_log(vector, vector, real, real)
+real exp_mod_normal_log(vector, vector, real, vector)
+real exp_mod_normal_log(vector, vector, real, row_vector)
+real exp_mod_normal_log(vector, vector, real, real[])
+real exp_mod_normal_log(vector, vector, vector, real)
+real exp_mod_normal_log(vector, vector, vector, vector)
+real exp_mod_normal_log(vector, vector, vector, row_vector)
+real exp_mod_normal_log(vector, vector, vector, real[])
+real exp_mod_normal_log(vector, vector, row_vector, real)
+real exp_mod_normal_log(vector, vector, row_vector, vector)
+real exp_mod_normal_log(vector, vector, row_vector, row_vector)
+real exp_mod_normal_log(vector, vector, row_vector, real[])
+real exp_mod_normal_log(vector, vector, real[], real)
+real exp_mod_normal_log(vector, vector, real[], vector)
+real exp_mod_normal_log(vector, vector, real[], row_vector)
+real exp_mod_normal_log(vector, vector, real[], real[])
+real exp_mod_normal_log(vector, row_vector, real, real)
+real exp_mod_normal_log(vector, row_vector, real, vector)
+real exp_mod_normal_log(vector, row_vector, real, row_vector)
+real exp_mod_normal_log(vector, row_vector, real, real[])
+real exp_mod_normal_log(vector, row_vector, vector, real)
+real exp_mod_normal_log(vector, row_vector, vector, vector)
+real exp_mod_normal_log(vector, row_vector, vector, row_vector)
+real exp_mod_normal_log(vector, row_vector, vector, real[])
+real exp_mod_normal_log(vector, row_vector, row_vector, real)
+real exp_mod_normal_log(vector, row_vector, row_vector, vector)
+real exp_mod_normal_log(vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_log(vector, row_vector, row_vector, real[])
+real exp_mod_normal_log(vector, row_vector, real[], real)
+real exp_mod_normal_log(vector, row_vector, real[], vector)
+real exp_mod_normal_log(vector, row_vector, real[], row_vector)
+real exp_mod_normal_log(vector, row_vector, real[], real[])
+real exp_mod_normal_log(vector, real[], real, real)
+real exp_mod_normal_log(vector, real[], real, vector)
+real exp_mod_normal_log(vector, real[], real, row_vector)
+real exp_mod_normal_log(vector, real[], real, real[])
+real exp_mod_normal_log(vector, real[], vector, real)
+real exp_mod_normal_log(vector, real[], vector, vector)
+real exp_mod_normal_log(vector, real[], vector, row_vector)
+real exp_mod_normal_log(vector, real[], vector, real[])
+real exp_mod_normal_log(vector, real[], row_vector, real)
+real exp_mod_normal_log(vector, real[], row_vector, vector)
+real exp_mod_normal_log(vector, real[], row_vector, row_vector)
+real exp_mod_normal_log(vector, real[], row_vector, real[])
+real exp_mod_normal_log(vector, real[], real[], real)
+real exp_mod_normal_log(vector, real[], real[], vector)
+real exp_mod_normal_log(vector, real[], real[], row_vector)
+real exp_mod_normal_log(vector, real[], real[], real[])
+real exp_mod_normal_log(row_vector, real, real, real)
+real exp_mod_normal_log(row_vector, real, real, vector)
+real exp_mod_normal_log(row_vector, real, real, row_vector)
+real exp_mod_normal_log(row_vector, real, real, real[])
+real exp_mod_normal_log(row_vector, real, vector, real)
+real exp_mod_normal_log(row_vector, real, vector, vector)
+real exp_mod_normal_log(row_vector, real, vector, row_vector)
+real exp_mod_normal_log(row_vector, real, vector, real[])
+real exp_mod_normal_log(row_vector, real, row_vector, real)
+real exp_mod_normal_log(row_vector, real, row_vector, vector)
+real exp_mod_normal_log(row_vector, real, row_vector, row_vector)
+real exp_mod_normal_log(row_vector, real, row_vector, real[])
+real exp_mod_normal_log(row_vector, real, real[], real)
+real exp_mod_normal_log(row_vector, real, real[], vector)
+real exp_mod_normal_log(row_vector, real, real[], row_vector)
+real exp_mod_normal_log(row_vector, real, real[], real[])
+real exp_mod_normal_log(row_vector, vector, real, real)
+real exp_mod_normal_log(row_vector, vector, real, vector)
+real exp_mod_normal_log(row_vector, vector, real, row_vector)
+real exp_mod_normal_log(row_vector, vector, real, real[])
+real exp_mod_normal_log(row_vector, vector, vector, real)
+real exp_mod_normal_log(row_vector, vector, vector, vector)
+real exp_mod_normal_log(row_vector, vector, vector, row_vector)
+real exp_mod_normal_log(row_vector, vector, vector, real[])
+real exp_mod_normal_log(row_vector, vector, row_vector, real)
+real exp_mod_normal_log(row_vector, vector, row_vector, vector)
+real exp_mod_normal_log(row_vector, vector, row_vector, row_vector)
+real exp_mod_normal_log(row_vector, vector, row_vector, real[])
+real exp_mod_normal_log(row_vector, vector, real[], real)
+real exp_mod_normal_log(row_vector, vector, real[], vector)
+real exp_mod_normal_log(row_vector, vector, real[], row_vector)
+real exp_mod_normal_log(row_vector, vector, real[], real[])
+real exp_mod_normal_log(row_vector, row_vector, real, real)
+real exp_mod_normal_log(row_vector, row_vector, real, vector)
+real exp_mod_normal_log(row_vector, row_vector, real, row_vector)
+real exp_mod_normal_log(row_vector, row_vector, real, real[])
+real exp_mod_normal_log(row_vector, row_vector, vector, real)
+real exp_mod_normal_log(row_vector, row_vector, vector, vector)
+real exp_mod_normal_log(row_vector, row_vector, vector, row_vector)
+real exp_mod_normal_log(row_vector, row_vector, vector, real[])
+real exp_mod_normal_log(row_vector, row_vector, row_vector, real)
+real exp_mod_normal_log(row_vector, row_vector, row_vector, vector)
+real exp_mod_normal_log(row_vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_log(row_vector, row_vector, row_vector, real[])
+real exp_mod_normal_log(row_vector, row_vector, real[], real)
+real exp_mod_normal_log(row_vector, row_vector, real[], vector)
+real exp_mod_normal_log(row_vector, row_vector, real[], row_vector)
+real exp_mod_normal_log(row_vector, row_vector, real[], real[])
+real exp_mod_normal_log(row_vector, real[], real, real)
+real exp_mod_normal_log(row_vector, real[], real, vector)
+real exp_mod_normal_log(row_vector, real[], real, row_vector)
+real exp_mod_normal_log(row_vector, real[], real, real[])
+real exp_mod_normal_log(row_vector, real[], vector, real)
+real exp_mod_normal_log(row_vector, real[], vector, vector)
+real exp_mod_normal_log(row_vector, real[], vector, row_vector)
+real exp_mod_normal_log(row_vector, real[], vector, real[])
+real exp_mod_normal_log(row_vector, real[], row_vector, real)
+real exp_mod_normal_log(row_vector, real[], row_vector, vector)
+real exp_mod_normal_log(row_vector, real[], row_vector, row_vector)
+real exp_mod_normal_log(row_vector, real[], row_vector, real[])
+real exp_mod_normal_log(row_vector, real[], real[], real)
+real exp_mod_normal_log(row_vector, real[], real[], vector)
+real exp_mod_normal_log(row_vector, real[], real[], row_vector)
+real exp_mod_normal_log(row_vector, real[], real[], real[])
+real exp_mod_normal_log(real[], real, real, vector)
+real exp_mod_normal_log(real[], real, real, row_vector)
+real exp_mod_normal_log(real[], real, vector, real)
+real exp_mod_normal_log(real[], real, vector, vector)
+real exp_mod_normal_log(real[], real, vector, row_vector)
+real exp_mod_normal_log(real[], real, vector, real[])
+real exp_mod_normal_log(real[], real, row_vector, real)
+real exp_mod_normal_log(real[], real, row_vector, vector)
+real exp_mod_normal_log(real[], real, row_vector, row_vector)
+real exp_mod_normal_log(real[], real, row_vector, real[])
+real exp_mod_normal_log(real[], real, real[], vector)
+real exp_mod_normal_log(real[], real, real[], row_vector)
+real exp_mod_normal_log(real[], vector, real, real)
+real exp_mod_normal_log(real[], vector, real, vector)
+real exp_mod_normal_log(real[], vector, real, row_vector)
+real exp_mod_normal_log(real[], vector, real, real[])
+real exp_mod_normal_log(real[], vector, vector, real)
+real exp_mod_normal_log(real[], vector, vector, vector)
+real exp_mod_normal_log(real[], vector, vector, row_vector)
+real exp_mod_normal_log(real[], vector, vector, real[])
+real exp_mod_normal_log(real[], vector, row_vector, real)
+real exp_mod_normal_log(real[], vector, row_vector, vector)
+real exp_mod_normal_log(real[], vector, row_vector, row_vector)
+real exp_mod_normal_log(real[], vector, row_vector, real[])
+real exp_mod_normal_log(real[], vector, real[], real)
+real exp_mod_normal_log(real[], vector, real[], vector)
+real exp_mod_normal_log(real[], vector, real[], row_vector)
+real exp_mod_normal_log(real[], vector, real[], real[])
+real exp_mod_normal_log(real[], row_vector, real, real)
+real exp_mod_normal_log(real[], row_vector, real, vector)
+real exp_mod_normal_log(real[], row_vector, real, row_vector)
+real exp_mod_normal_log(real[], row_vector, real, real[])
+real exp_mod_normal_log(real[], row_vector, vector, real)
+real exp_mod_normal_log(real[], row_vector, vector, vector)
+real exp_mod_normal_log(real[], row_vector, vector, row_vector)
+real exp_mod_normal_log(real[], row_vector, vector, real[])
+real exp_mod_normal_log(real[], row_vector, row_vector, real)
+real exp_mod_normal_log(real[], row_vector, row_vector, vector)
+real exp_mod_normal_log(real[], row_vector, row_vector, row_vector)
+real exp_mod_normal_log(real[], row_vector, row_vector, real[])
+real exp_mod_normal_log(real[], row_vector, real[], real)
+real exp_mod_normal_log(real[], row_vector, real[], vector)
+real exp_mod_normal_log(real[], row_vector, real[], row_vector)
+real exp_mod_normal_log(real[], row_vector, real[], real[])
+real exp_mod_normal_log(real[], real[], real, vector)
+real exp_mod_normal_log(real[], real[], real, row_vector)
+real exp_mod_normal_log(real[], real[], vector, real)
+real exp_mod_normal_log(real[], real[], vector, vector)
+real exp_mod_normal_log(real[], real[], vector, row_vector)
+real exp_mod_normal_log(real[], real[], vector, real[])
+real exp_mod_normal_log(real[], real[], row_vector, real)
+real exp_mod_normal_log(real[], real[], row_vector, vector)
+real exp_mod_normal_log(real[], real[], row_vector, row_vector)
+real exp_mod_normal_log(real[], real[], row_vector, real[])
+real exp_mod_normal_log(real[], real[], real[], vector)
+real exp_mod_normal_log(real[], real[], real[], row_vector)
+real exp_mod_normal_lpdf(real, real, real, vector)
+real exp_mod_normal_lpdf(real, real, real, row_vector)
+real exp_mod_normal_lpdf(real, real, vector, real)
+real exp_mod_normal_lpdf(real, real, vector, vector)
+real exp_mod_normal_lpdf(real, real, vector, row_vector)
+real exp_mod_normal_lpdf(real, real, vector, real[])
+real exp_mod_normal_lpdf(real, real, row_vector, real)
+real exp_mod_normal_lpdf(real, real, row_vector, vector)
+real exp_mod_normal_lpdf(real, real, row_vector, row_vector)
+real exp_mod_normal_lpdf(real, real, row_vector, real[])
+real exp_mod_normal_lpdf(real, real, real[], vector)
+real exp_mod_normal_lpdf(real, real, real[], row_vector)
+real exp_mod_normal_lpdf(real, vector, real, real)
+real exp_mod_normal_lpdf(real, vector, real, vector)
+real exp_mod_normal_lpdf(real, vector, real, row_vector)
+real exp_mod_normal_lpdf(real, vector, real, real[])
+real exp_mod_normal_lpdf(real, vector, vector, real)
+real exp_mod_normal_lpdf(real, vector, vector, vector)
+real exp_mod_normal_lpdf(real, vector, vector, row_vector)
+real exp_mod_normal_lpdf(real, vector, vector, real[])
+real exp_mod_normal_lpdf(real, vector, row_vector, real)
+real exp_mod_normal_lpdf(real, vector, row_vector, vector)
+real exp_mod_normal_lpdf(real, vector, row_vector, row_vector)
+real exp_mod_normal_lpdf(real, vector, row_vector, real[])
+real exp_mod_normal_lpdf(real, vector, real[], real)
+real exp_mod_normal_lpdf(real, vector, real[], vector)
+real exp_mod_normal_lpdf(real, vector, real[], row_vector)
+real exp_mod_normal_lpdf(real, vector, real[], real[])
+real exp_mod_normal_lpdf(real, row_vector, real, real)
+real exp_mod_normal_lpdf(real, row_vector, real, vector)
+real exp_mod_normal_lpdf(real, row_vector, real, row_vector)
+real exp_mod_normal_lpdf(real, row_vector, real, real[])
+real exp_mod_normal_lpdf(real, row_vector, vector, real)
+real exp_mod_normal_lpdf(real, row_vector, vector, vector)
+real exp_mod_normal_lpdf(real, row_vector, vector, row_vector)
+real exp_mod_normal_lpdf(real, row_vector, vector, real[])
+real exp_mod_normal_lpdf(real, row_vector, row_vector, real)
+real exp_mod_normal_lpdf(real, row_vector, row_vector, vector)
+real exp_mod_normal_lpdf(real, row_vector, row_vector, row_vector)
+real exp_mod_normal_lpdf(real, row_vector, row_vector, real[])
+real exp_mod_normal_lpdf(real, row_vector, real[], real)
+real exp_mod_normal_lpdf(real, row_vector, real[], vector)
+real exp_mod_normal_lpdf(real, row_vector, real[], row_vector)
+real exp_mod_normal_lpdf(real, row_vector, real[], real[])
+real exp_mod_normal_lpdf(real, real[], real, vector)
+real exp_mod_normal_lpdf(real, real[], real, row_vector)
+real exp_mod_normal_lpdf(real, real[], vector, real)
+real exp_mod_normal_lpdf(real, real[], vector, vector)
+real exp_mod_normal_lpdf(real, real[], vector, row_vector)
+real exp_mod_normal_lpdf(real, real[], vector, real[])
+real exp_mod_normal_lpdf(real, real[], row_vector, real)
+real exp_mod_normal_lpdf(real, real[], row_vector, vector)
+real exp_mod_normal_lpdf(real, real[], row_vector, row_vector)
+real exp_mod_normal_lpdf(real, real[], row_vector, real[])
+real exp_mod_normal_lpdf(real, real[], real[], vector)
+real exp_mod_normal_lpdf(real, real[], real[], row_vector)
+real exp_mod_normal_lpdf(vector, real, real, real)
+real exp_mod_normal_lpdf(vector, real, real, vector)
+real exp_mod_normal_lpdf(vector, real, real, row_vector)
+real exp_mod_normal_lpdf(vector, real, real, real[])
+real exp_mod_normal_lpdf(vector, real, vector, real)
+real exp_mod_normal_lpdf(vector, real, vector, vector)
+real exp_mod_normal_lpdf(vector, real, vector, row_vector)
+real exp_mod_normal_lpdf(vector, real, vector, real[])
+real exp_mod_normal_lpdf(vector, real, row_vector, real)
+real exp_mod_normal_lpdf(vector, real, row_vector, vector)
+real exp_mod_normal_lpdf(vector, real, row_vector, row_vector)
+real exp_mod_normal_lpdf(vector, real, row_vector, real[])
+real exp_mod_normal_lpdf(vector, real, real[], real)
+real exp_mod_normal_lpdf(vector, real, real[], vector)
+real exp_mod_normal_lpdf(vector, real, real[], row_vector)
+real exp_mod_normal_lpdf(vector, real, real[], real[])
+real exp_mod_normal_lpdf(vector, vector, real, real)
+real exp_mod_normal_lpdf(vector, vector, real, vector)
+real exp_mod_normal_lpdf(vector, vector, real, row_vector)
+real exp_mod_normal_lpdf(vector, vector, real, real[])
+real exp_mod_normal_lpdf(vector, vector, vector, real)
+real exp_mod_normal_lpdf(vector, vector, vector, vector)
+real exp_mod_normal_lpdf(vector, vector, vector, row_vector)
+real exp_mod_normal_lpdf(vector, vector, vector, real[])
+real exp_mod_normal_lpdf(vector, vector, row_vector, real)
+real exp_mod_normal_lpdf(vector, vector, row_vector, vector)
+real exp_mod_normal_lpdf(vector, vector, row_vector, row_vector)
+real exp_mod_normal_lpdf(vector, vector, row_vector, real[])
+real exp_mod_normal_lpdf(vector, vector, real[], real)
+real exp_mod_normal_lpdf(vector, vector, real[], vector)
+real exp_mod_normal_lpdf(vector, vector, real[], row_vector)
+real exp_mod_normal_lpdf(vector, vector, real[], real[])
+real exp_mod_normal_lpdf(vector, row_vector, real, real)
+real exp_mod_normal_lpdf(vector, row_vector, real, vector)
+real exp_mod_normal_lpdf(vector, row_vector, real, row_vector)
+real exp_mod_normal_lpdf(vector, row_vector, real, real[])
+real exp_mod_normal_lpdf(vector, row_vector, vector, real)
+real exp_mod_normal_lpdf(vector, row_vector, vector, vector)
+real exp_mod_normal_lpdf(vector, row_vector, vector, row_vector)
+real exp_mod_normal_lpdf(vector, row_vector, vector, real[])
+real exp_mod_normal_lpdf(vector, row_vector, row_vector, real)
+real exp_mod_normal_lpdf(vector, row_vector, row_vector, vector)
+real exp_mod_normal_lpdf(vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_lpdf(vector, row_vector, row_vector, real[])
+real exp_mod_normal_lpdf(vector, row_vector, real[], real)
+real exp_mod_normal_lpdf(vector, row_vector, real[], vector)
+real exp_mod_normal_lpdf(vector, row_vector, real[], row_vector)
+real exp_mod_normal_lpdf(vector, row_vector, real[], real[])
+real exp_mod_normal_lpdf(vector, real[], real, real)
+real exp_mod_normal_lpdf(vector, real[], real, vector)
+real exp_mod_normal_lpdf(vector, real[], real, row_vector)
+real exp_mod_normal_lpdf(vector, real[], real, real[])
+real exp_mod_normal_lpdf(vector, real[], vector, real)
+real exp_mod_normal_lpdf(vector, real[], vector, vector)
+real exp_mod_normal_lpdf(vector, real[], vector, row_vector)
+real exp_mod_normal_lpdf(vector, real[], vector, real[])
+real exp_mod_normal_lpdf(vector, real[], row_vector, real)
+real exp_mod_normal_lpdf(vector, real[], row_vector, vector)
+real exp_mod_normal_lpdf(vector, real[], row_vector, row_vector)
+real exp_mod_normal_lpdf(vector, real[], row_vector, real[])
+real exp_mod_normal_lpdf(vector, real[], real[], real)
+real exp_mod_normal_lpdf(vector, real[], real[], vector)
+real exp_mod_normal_lpdf(vector, real[], real[], row_vector)
+real exp_mod_normal_lpdf(vector, real[], real[], real[])
+real exp_mod_normal_lpdf(row_vector, real, real, real)
+real exp_mod_normal_lpdf(row_vector, real, real, vector)
+real exp_mod_normal_lpdf(row_vector, real, real, row_vector)
+real exp_mod_normal_lpdf(row_vector, real, real, real[])
+real exp_mod_normal_lpdf(row_vector, real, vector, real)
+real exp_mod_normal_lpdf(row_vector, real, vector, vector)
+real exp_mod_normal_lpdf(row_vector, real, vector, row_vector)
+real exp_mod_normal_lpdf(row_vector, real, vector, real[])
+real exp_mod_normal_lpdf(row_vector, real, row_vector, real)
+real exp_mod_normal_lpdf(row_vector, real, row_vector, vector)
+real exp_mod_normal_lpdf(row_vector, real, row_vector, row_vector)
+real exp_mod_normal_lpdf(row_vector, real, row_vector, real[])
+real exp_mod_normal_lpdf(row_vector, real, real[], real)
+real exp_mod_normal_lpdf(row_vector, real, real[], vector)
+real exp_mod_normal_lpdf(row_vector, real, real[], row_vector)
+real exp_mod_normal_lpdf(row_vector, real, real[], real[])
+real exp_mod_normal_lpdf(row_vector, vector, real, real)
+real exp_mod_normal_lpdf(row_vector, vector, real, vector)
+real exp_mod_normal_lpdf(row_vector, vector, real, row_vector)
+real exp_mod_normal_lpdf(row_vector, vector, real, real[])
+real exp_mod_normal_lpdf(row_vector, vector, vector, real)
+real exp_mod_normal_lpdf(row_vector, vector, vector, vector)
+real exp_mod_normal_lpdf(row_vector, vector, vector, row_vector)
+real exp_mod_normal_lpdf(row_vector, vector, vector, real[])
+real exp_mod_normal_lpdf(row_vector, vector, row_vector, real)
+real exp_mod_normal_lpdf(row_vector, vector, row_vector, vector)
+real exp_mod_normal_lpdf(row_vector, vector, row_vector, row_vector)
+real exp_mod_normal_lpdf(row_vector, vector, row_vector, real[])
+real exp_mod_normal_lpdf(row_vector, vector, real[], real)
+real exp_mod_normal_lpdf(row_vector, vector, real[], vector)
+real exp_mod_normal_lpdf(row_vector, vector, real[], row_vector)
+real exp_mod_normal_lpdf(row_vector, vector, real[], real[])
+real exp_mod_normal_lpdf(row_vector, row_vector, real, real)
+real exp_mod_normal_lpdf(row_vector, row_vector, real, vector)
+real exp_mod_normal_lpdf(row_vector, row_vector, real, row_vector)
+real exp_mod_normal_lpdf(row_vector, row_vector, real, real[])
+real exp_mod_normal_lpdf(row_vector, row_vector, vector, real)
+real exp_mod_normal_lpdf(row_vector, row_vector, vector, vector)
+real exp_mod_normal_lpdf(row_vector, row_vector, vector, row_vector)
+real exp_mod_normal_lpdf(row_vector, row_vector, vector, real[])
+real exp_mod_normal_lpdf(row_vector, row_vector, row_vector, real)
+real exp_mod_normal_lpdf(row_vector, row_vector, row_vector, vector)
+real exp_mod_normal_lpdf(row_vector, row_vector, row_vector, row_vector)
+real exp_mod_normal_lpdf(row_vector, row_vector, row_vector, real[])
+real exp_mod_normal_lpdf(row_vector, row_vector, real[], real)
+real exp_mod_normal_lpdf(row_vector, row_vector, real[], vector)
+real exp_mod_normal_lpdf(row_vector, row_vector, real[], row_vector)
+real exp_mod_normal_lpdf(row_vector, row_vector, real[], real[])
+real exp_mod_normal_lpdf(row_vector, real[], real, real)
+real exp_mod_normal_lpdf(row_vector, real[], real, vector)
+real exp_mod_normal_lpdf(row_vector, real[], real, row_vector)
+real exp_mod_normal_lpdf(row_vector, real[], real, real[])
+real exp_mod_normal_lpdf(row_vector, real[], vector, real)
+real exp_mod_normal_lpdf(row_vector, real[], vector, vector)
+real exp_mod_normal_lpdf(row_vector, real[], vector, row_vector)
+real exp_mod_normal_lpdf(row_vector, real[], vector, real[])
+real exp_mod_normal_lpdf(row_vector, real[], row_vector, real)
+real exp_mod_normal_lpdf(row_vector, real[], row_vector, vector)
+real exp_mod_normal_lpdf(row_vector, real[], row_vector, row_vector)
+real exp_mod_normal_lpdf(row_vector, real[], row_vector, real[])
+real exp_mod_normal_lpdf(row_vector, real[], real[], real)
+real exp_mod_normal_lpdf(row_vector, real[], real[], vector)
+real exp_mod_normal_lpdf(row_vector, real[], real[], row_vector)
+real exp_mod_normal_lpdf(row_vector, real[], real[], real[])
+real exp_mod_normal_lpdf(real[], real, real, vector)
+real exp_mod_normal_lpdf(real[], real, real, row_vector)
+real exp_mod_normal_lpdf(real[], real, vector, real)
+real exp_mod_normal_lpdf(real[], real, vector, vector)
+real exp_mod_normal_lpdf(real[], real, vector, row_vector)
+real exp_mod_normal_lpdf(real[], real, vector, real[])
+real exp_mod_normal_lpdf(real[], real, row_vector, real)
+real exp_mod_normal_lpdf(real[], real, row_vector, vector)
+real exp_mod_normal_lpdf(real[], real, row_vector, row_vector)
+real exp_mod_normal_lpdf(real[], real, row_vector, real[])
+real exp_mod_normal_lpdf(real[], real, real[], vector)
+real exp_mod_normal_lpdf(real[], real, real[], row_vector)
+real exp_mod_normal_lpdf(real[], vector, real, real)
+real exp_mod_normal_lpdf(real[], vector, real, vector)
+real exp_mod_normal_lpdf(real[], vector, real, row_vector)
+real exp_mod_normal_lpdf(real[], vector, real, real[])
+real exp_mod_normal_lpdf(real[], vector, vector, real)
+real exp_mod_normal_lpdf(real[], vector, vector, vector)
+real exp_mod_normal_lpdf(real[], vector, vector, row_vector)
+real exp_mod_normal_lpdf(real[], vector, vector, real[])
+real exp_mod_normal_lpdf(real[], vector, row_vector, real)
+real exp_mod_normal_lpdf(real[], vector, row_vector, vector)
+real exp_mod_normal_lpdf(real[], vector, row_vector, row_vector)
+real exp_mod_normal_lpdf(real[], vector, row_vector, real[])
+real exp_mod_normal_lpdf(real[], vector, real[], real)
+real exp_mod_normal_lpdf(real[], vector, real[], vector)
+real exp_mod_normal_lpdf(real[], vector, real[], row_vector)
+real exp_mod_normal_lpdf(real[], vector, real[], real[])
+real exp_mod_normal_lpdf(real[], row_vector, real, real)
+real exp_mod_normal_lpdf(real[], row_vector, real, vector)
+real exp_mod_normal_lpdf(real[], row_vector, real, row_vector)
+real exp_mod_normal_lpdf(real[], row_vector, real, real[])
+real exp_mod_normal_lpdf(real[], row_vector, vector, real)
+real exp_mod_normal_lpdf(real[], row_vector, vector, vector)
+real exp_mod_normal_lpdf(real[], row_vector, vector, row_vector)
+real exp_mod_normal_lpdf(real[], row_vector, vector, real[])
+real exp_mod_normal_lpdf(real[], row_vector, row_vector, real)
+real exp_mod_normal_lpdf(real[], row_vector, row_vector, vector)
+real exp_mod_normal_lpdf(real[], row_vector, row_vector, row_vector)
+real exp_mod_normal_lpdf(real[], row_vector, row_vector, real[])
+real exp_mod_normal_lpdf(real[], row_vector, real[], real)
+real exp_mod_normal_lpdf(real[], row_vector, real[], vector)
+real exp_mod_normal_lpdf(real[], row_vector, real[], row_vector)
+real exp_mod_normal_lpdf(real[], row_vector, real[], real[])
+real exp_mod_normal_lpdf(real[], real[], real, vector)
+real exp_mod_normal_lpdf(real[], real[], real, row_vector)
+real exp_mod_normal_lpdf(real[], real[], vector, real)
+real exp_mod_normal_lpdf(real[], real[], vector, vector)
+real exp_mod_normal_lpdf(real[], real[], vector, row_vector)
+real exp_mod_normal_lpdf(real[], real[], vector, real[])
+real exp_mod_normal_lpdf(real[], real[], row_vector, real)
+real exp_mod_normal_lpdf(real[], real[], row_vector, vector)
+real exp_mod_normal_lpdf(real[], real[], row_vector, row_vector)
+real exp_mod_normal_lpdf(real[], real[], row_vector, real[])
+real exp_mod_normal_lpdf(real[], real[], real[], vector)
+real exp_mod_normal_lpdf(real[], real[], real[], row_vector)
+real[] exp_mod_normal_rng(int, int, vector)
+real[] exp_mod_normal_rng(int, int, row_vector)
+real[] exp_mod_normal_rng(int, real, vector)
+real[] exp_mod_normal_rng(int, real, row_vector)
+real[] exp_mod_normal_rng(int, vector, int)
+real[] exp_mod_normal_rng(int, vector, real)
+real[] exp_mod_normal_rng(int, vector, vector)
+real[] exp_mod_normal_rng(int, vector, row_vector)
+real[] exp_mod_normal_rng(int, vector, int[])
+real[] exp_mod_normal_rng(int, vector, real[])
+real[] exp_mod_normal_rng(int, row_vector, int)
+real[] exp_mod_normal_rng(int, row_vector, real)
+real[] exp_mod_normal_rng(int, row_vector, vector)
+real[] exp_mod_normal_rng(int, row_vector, row_vector)
+real[] exp_mod_normal_rng(int, row_vector, int[])
+real[] exp_mod_normal_rng(int, row_vector, real[])
+real[] exp_mod_normal_rng(int, int[], vector)
+real[] exp_mod_normal_rng(int, int[], row_vector)
+real[] exp_mod_normal_rng(int, real[], vector)
+real[] exp_mod_normal_rng(int, real[], row_vector)
+real[] exp_mod_normal_rng(real, int, vector)
+real[] exp_mod_normal_rng(real, int, row_vector)
+real[] exp_mod_normal_rng(real, real, vector)
+real[] exp_mod_normal_rng(real, real, row_vector)
+real[] exp_mod_normal_rng(real, vector, int)
+real[] exp_mod_normal_rng(real, vector, real)
+real[] exp_mod_normal_rng(real, vector, vector)
+real[] exp_mod_normal_rng(real, vector, row_vector)
+real[] exp_mod_normal_rng(real, vector, int[])
+real[] exp_mod_normal_rng(real, vector, real[])
+real[] exp_mod_normal_rng(real, row_vector, int)
+real[] exp_mod_normal_rng(real, row_vector, real)
+real[] exp_mod_normal_rng(real, row_vector, vector)
+real[] exp_mod_normal_rng(real, row_vector, row_vector)
+real[] exp_mod_normal_rng(real, row_vector, int[])
+real[] exp_mod_normal_rng(real, row_vector, real[])
+real[] exp_mod_normal_rng(real, int[], vector)
+real[] exp_mod_normal_rng(real, int[], row_vector)
+real[] exp_mod_normal_rng(real, real[], vector)
+real[] exp_mod_normal_rng(real, real[], row_vector)
+real[] exp_mod_normal_rng(vector, int, int)
+real[] exp_mod_normal_rng(vector, int, real)
+real[] exp_mod_normal_rng(vector, int, vector)
+real[] exp_mod_normal_rng(vector, int, row_vector)
+real[] exp_mod_normal_rng(vector, int, int[])
+real[] exp_mod_normal_rng(vector, int, real[])
+real[] exp_mod_normal_rng(vector, real, int)
+real[] exp_mod_normal_rng(vector, real, real)
+real[] exp_mod_normal_rng(vector, real, vector)
+real[] exp_mod_normal_rng(vector, real, row_vector)
+real[] exp_mod_normal_rng(vector, real, int[])
+real[] exp_mod_normal_rng(vector, real, real[])
+real[] exp_mod_normal_rng(vector, vector, int)
+real[] exp_mod_normal_rng(vector, vector, real)
+real[] exp_mod_normal_rng(vector, vector, vector)
+real[] exp_mod_normal_rng(vector, vector, row_vector)
+real[] exp_mod_normal_rng(vector, vector, int[])
+real[] exp_mod_normal_rng(vector, vector, real[])
+real[] exp_mod_normal_rng(vector, row_vector, int)
+real[] exp_mod_normal_rng(vector, row_vector, real)
+real[] exp_mod_normal_rng(vector, row_vector, vector)
+real[] exp_mod_normal_rng(vector, row_vector, row_vector)
+real[] exp_mod_normal_rng(vector, row_vector, int[])
+real[] exp_mod_normal_rng(vector, row_vector, real[])
+real[] exp_mod_normal_rng(vector, int[], int)
+real[] exp_mod_normal_rng(vector, int[], real)
+real[] exp_mod_normal_rng(vector, int[], vector)
+real[] exp_mod_normal_rng(vector, int[], row_vector)
+real[] exp_mod_normal_rng(vector, int[], int[])
+real[] exp_mod_normal_rng(vector, int[], real[])
+real[] exp_mod_normal_rng(vector, real[], int)
+real[] exp_mod_normal_rng(vector, real[], real)
+real[] exp_mod_normal_rng(vector, real[], vector)
+real[] exp_mod_normal_rng(vector, real[], row_vector)
+real[] exp_mod_normal_rng(vector, real[], int[])
+real[] exp_mod_normal_rng(vector, real[], real[])
+real[] exp_mod_normal_rng(row_vector, int, int)
+real[] exp_mod_normal_rng(row_vector, int, real)
+real[] exp_mod_normal_rng(row_vector, int, vector)
+real[] exp_mod_normal_rng(row_vector, int, row_vector)
+real[] exp_mod_normal_rng(row_vector, int, int[])
+real[] exp_mod_normal_rng(row_vector, int, real[])
+real[] exp_mod_normal_rng(row_vector, real, int)
+real[] exp_mod_normal_rng(row_vector, real, real)
+real[] exp_mod_normal_rng(row_vector, real, vector)
+real[] exp_mod_normal_rng(row_vector, real, row_vector)
+real[] exp_mod_normal_rng(row_vector, real, int[])
+real[] exp_mod_normal_rng(row_vector, real, real[])
+real[] exp_mod_normal_rng(row_vector, vector, int)
+real[] exp_mod_normal_rng(row_vector, vector, real)
+real[] exp_mod_normal_rng(row_vector, vector, vector)
+real[] exp_mod_normal_rng(row_vector, vector, row_vector)
+real[] exp_mod_normal_rng(row_vector, vector, int[])
+real[] exp_mod_normal_rng(row_vector, vector, real[])
+real[] exp_mod_normal_rng(row_vector, row_vector, int)
+real[] exp_mod_normal_rng(row_vector, row_vector, real)
+real[] exp_mod_normal_rng(row_vector, row_vector, vector)
+real[] exp_mod_normal_rng(row_vector, row_vector, row_vector)
+real[] exp_mod_normal_rng(row_vector, row_vector, int[])
+real[] exp_mod_normal_rng(row_vector, row_vector, real[])
+real[] exp_mod_normal_rng(row_vector, int[], int)
+real[] exp_mod_normal_rng(row_vector, int[], real)
+real[] exp_mod_normal_rng(row_vector, int[], vector)
+real[] exp_mod_normal_rng(row_vector, int[], row_vector)
+real[] exp_mod_normal_rng(row_vector, int[], int[])
+real[] exp_mod_normal_rng(row_vector, int[], real[])
+real[] exp_mod_normal_rng(row_vector, real[], int)
+real[] exp_mod_normal_rng(row_vector, real[], real)
+real[] exp_mod_normal_rng(row_vector, real[], vector)
+real[] exp_mod_normal_rng(row_vector, real[], row_vector)
+real[] exp_mod_normal_rng(row_vector, real[], int[])
+real[] exp_mod_normal_rng(row_vector, real[], real[])
+real[] exp_mod_normal_rng(int[], int, vector)
+real[] exp_mod_normal_rng(int[], int, row_vector)
+real[] exp_mod_normal_rng(int[], real, vector)
+real[] exp_mod_normal_rng(int[], real, row_vector)
+real[] exp_mod_normal_rng(int[], vector, int)
+real[] exp_mod_normal_rng(int[], vector, real)
+real[] exp_mod_normal_rng(int[], vector, vector)
+real[] exp_mod_normal_rng(int[], vector, row_vector)
+real[] exp_mod_normal_rng(int[], vector, int[])
+real[] exp_mod_normal_rng(int[], vector, real[])
+real[] exp_mod_normal_rng(int[], row_vector, int)
+real[] exp_mod_normal_rng(int[], row_vector, real)
+real[] exp_mod_normal_rng(int[], row_vector, vector)
+real[] exp_mod_normal_rng(int[], row_vector, row_vector)
+real[] exp_mod_normal_rng(int[], row_vector, int[])
+real[] exp_mod_normal_rng(int[], row_vector, real[])
+real[] exp_mod_normal_rng(int[], int[], vector)
+real[] exp_mod_normal_rng(int[], int[], row_vector)
+real[] exp_mod_normal_rng(int[], real[], vector)
+real[] exp_mod_normal_rng(int[], real[], row_vector)
+real[] exp_mod_normal_rng(real[], int, vector)
+real[] exp_mod_normal_rng(real[], int, row_vector)
+real[] exp_mod_normal_rng(real[], real, vector)
+real[] exp_mod_normal_rng(real[], real, row_vector)
+real[] exp_mod_normal_rng(real[], vector, int)
+real[] exp_mod_normal_rng(real[], vector, real)
+real[] exp_mod_normal_rng(real[], vector, vector)
+real[] exp_mod_normal_rng(real[], vector, row_vector)
+real[] exp_mod_normal_rng(real[], vector, int[])
+real[] exp_mod_normal_rng(real[], vector, real[])
+real[] exp_mod_normal_rng(real[], row_vector, int)
+real[] exp_mod_normal_rng(real[], row_vector, real)
+real[] exp_mod_normal_rng(real[], row_vector, vector)
+real[] exp_mod_normal_rng(real[], row_vector, row_vector)
+real[] exp_mod_normal_rng(real[], row_vector, int[])
+real[] exp_mod_normal_rng(real[], row_vector, real[])
+real[] exp_mod_normal_rng(real[], int[], vector)
+real[] exp_mod_normal_rng(real[], int[], row_vector)
+real[] exp_mod_normal_rng(real[], real[], vector)
+real[] exp_mod_normal_rng(real[], real[], row_vector)
+real exponential_ccdf_log(real, vector)
+real exponential_ccdf_log(real, row_vector)
+real exponential_ccdf_log(vector, real)
+real exponential_ccdf_log(vector, vector)
+real exponential_ccdf_log(vector, row_vector)
+real exponential_ccdf_log(vector, real[])
+real exponential_ccdf_log(row_vector, real)
+real exponential_ccdf_log(row_vector, vector)
+real exponential_ccdf_log(row_vector, row_vector)
+real exponential_ccdf_log(row_vector, real[])
+real exponential_ccdf_log(real[], vector)
+real exponential_ccdf_log(real[], row_vector)
+real exponential_cdf(real, vector)
+real exponential_cdf(real, row_vector)
+real exponential_cdf(vector, real)
+real exponential_cdf(vector, vector)
+real exponential_cdf(vector, row_vector)
+real exponential_cdf(vector, real[])
+real exponential_cdf(row_vector, real)
+real exponential_cdf(row_vector, vector)
+real exponential_cdf(row_vector, row_vector)
+real exponential_cdf(row_vector, real[])
+real exponential_cdf(real[], vector)
+real exponential_cdf(real[], row_vector)
+real exponential_cdf_log(real, vector)
+real exponential_cdf_log(real, row_vector)
+real exponential_cdf_log(vector, real)
+real exponential_cdf_log(vector, vector)
+real exponential_cdf_log(vector, row_vector)
+real exponential_cdf_log(vector, real[])
+real exponential_cdf_log(row_vector, real)
+real exponential_cdf_log(row_vector, vector)
+real exponential_cdf_log(row_vector, row_vector)
+real exponential_cdf_log(row_vector, real[])
+real exponential_cdf_log(real[], vector)
+real exponential_cdf_log(real[], row_vector)
+real exponential_lccdf(real, vector)
+real exponential_lccdf(real, row_vector)
+real exponential_lccdf(vector, real)
+real exponential_lccdf(vector, vector)
+real exponential_lccdf(vector, row_vector)
+real exponential_lccdf(vector, real[])
+real exponential_lccdf(row_vector, real)
+real exponential_lccdf(row_vector, vector)
+real exponential_lccdf(row_vector, row_vector)
+real exponential_lccdf(row_vector, real[])
+real exponential_lccdf(real[], vector)
+real exponential_lccdf(real[], row_vector)
+real exponential_lcdf(real, vector)
+real exponential_lcdf(real, row_vector)
+real exponential_lcdf(vector, real)
+real exponential_lcdf(vector, vector)
+real exponential_lcdf(vector, row_vector)
+real exponential_lcdf(vector, real[])
+real exponential_lcdf(row_vector, real)
+real exponential_lcdf(row_vector, vector)
+real exponential_lcdf(row_vector, row_vector)
+real exponential_lcdf(row_vector, real[])
+real exponential_lcdf(real[], vector)
+real exponential_lcdf(real[], row_vector)
+real exponential_log(real, vector)
+real exponential_log(real, row_vector)
+real exponential_log(vector, real)
+real exponential_log(vector, vector)
+real exponential_log(vector, row_vector)
+real exponential_log(vector, real[])
+real exponential_log(row_vector, real)
+real exponential_log(row_vector, vector)
+real exponential_log(row_vector, row_vector)
+real exponential_log(row_vector, real[])
+real exponential_log(real[], vector)
+real exponential_log(real[], row_vector)
+real exponential_lpdf(real, vector)
+real exponential_lpdf(real, row_vector)
+real exponential_lpdf(vector, real)
+real exponential_lpdf(vector, vector)
+real exponential_lpdf(vector, row_vector)
+real exponential_lpdf(vector, real[])
+real exponential_lpdf(row_vector, real)
+real exponential_lpdf(row_vector, vector)
+real exponential_lpdf(row_vector, row_vector)
+real exponential_lpdf(row_vector, real[])
+real exponential_lpdf(real[], vector)
+real exponential_lpdf(real[], row_vector)
+real[] exponential_rng(vector)
+real[] exponential_rng(row_vector)
+real frechet_ccdf_log(real, real, vector)
+real frechet_ccdf_log(real, real, row_vector)
+real frechet_ccdf_log(real, vector, real)
+real frechet_ccdf_log(real, vector, vector)
+real frechet_ccdf_log(real, vector, row_vector)
+real frechet_ccdf_log(real, vector, real[])
+real frechet_ccdf_log(real, row_vector, real)
+real frechet_ccdf_log(real, row_vector, vector)
+real frechet_ccdf_log(real, row_vector, row_vector)
+real frechet_ccdf_log(real, row_vector, real[])
+real frechet_ccdf_log(real, real[], vector)
+real frechet_ccdf_log(real, real[], row_vector)
+real frechet_ccdf_log(vector, real, real)
+real frechet_ccdf_log(vector, real, vector)
+real frechet_ccdf_log(vector, real, row_vector)
+real frechet_ccdf_log(vector, real, real[])
+real frechet_ccdf_log(vector, vector, real)
+real frechet_ccdf_log(vector, vector, vector)
+real frechet_ccdf_log(vector, vector, row_vector)
+real frechet_ccdf_log(vector, vector, real[])
+real frechet_ccdf_log(vector, row_vector, real)
+real frechet_ccdf_log(vector, row_vector, vector)
+real frechet_ccdf_log(vector, row_vector, row_vector)
+real frechet_ccdf_log(vector, row_vector, real[])
+real frechet_ccdf_log(vector, real[], real)
+real frechet_ccdf_log(vector, real[], vector)
+real frechet_ccdf_log(vector, real[], row_vector)
+real frechet_ccdf_log(vector, real[], real[])
+real frechet_ccdf_log(row_vector, real, real)
+real frechet_ccdf_log(row_vector, real, vector)
+real frechet_ccdf_log(row_vector, real, row_vector)
+real frechet_ccdf_log(row_vector, real, real[])
+real frechet_ccdf_log(row_vector, vector, real)
+real frechet_ccdf_log(row_vector, vector, vector)
+real frechet_ccdf_log(row_vector, vector, row_vector)
+real frechet_ccdf_log(row_vector, vector, real[])
+real frechet_ccdf_log(row_vector, row_vector, real)
+real frechet_ccdf_log(row_vector, row_vector, vector)
+real frechet_ccdf_log(row_vector, row_vector, row_vector)
+real frechet_ccdf_log(row_vector, row_vector, real[])
+real frechet_ccdf_log(row_vector, real[], real)
+real frechet_ccdf_log(row_vector, real[], vector)
+real frechet_ccdf_log(row_vector, real[], row_vector)
+real frechet_ccdf_log(row_vector, real[], real[])
+real frechet_ccdf_log(real[], real, vector)
+real frechet_ccdf_log(real[], real, row_vector)
+real frechet_ccdf_log(real[], vector, real)
+real frechet_ccdf_log(real[], vector, vector)
+real frechet_ccdf_log(real[], vector, row_vector)
+real frechet_ccdf_log(real[], vector, real[])
+real frechet_ccdf_log(real[], row_vector, real)
+real frechet_ccdf_log(real[], row_vector, vector)
+real frechet_ccdf_log(real[], row_vector, row_vector)
+real frechet_ccdf_log(real[], row_vector, real[])
+real frechet_ccdf_log(real[], real[], vector)
+real frechet_ccdf_log(real[], real[], row_vector)
+real frechet_cdf(real, real, vector)
+real frechet_cdf(real, real, row_vector)
+real frechet_cdf(real, vector, real)
+real frechet_cdf(real, vector, vector)
+real frechet_cdf(real, vector, row_vector)
+real frechet_cdf(real, vector, real[])
+real frechet_cdf(real, row_vector, real)
+real frechet_cdf(real, row_vector, vector)
+real frechet_cdf(real, row_vector, row_vector)
+real frechet_cdf(real, row_vector, real[])
+real frechet_cdf(real, real[], vector)
+real frechet_cdf(real, real[], row_vector)
+real frechet_cdf(vector, real, real)
+real frechet_cdf(vector, real, vector)
+real frechet_cdf(vector, real, row_vector)
+real frechet_cdf(vector, real, real[])
+real frechet_cdf(vector, vector, real)
+real frechet_cdf(vector, vector, vector)
+real frechet_cdf(vector, vector, row_vector)
+real frechet_cdf(vector, vector, real[])
+real frechet_cdf(vector, row_vector, real)
+real frechet_cdf(vector, row_vector, vector)
+real frechet_cdf(vector, row_vector, row_vector)
+real frechet_cdf(vector, row_vector, real[])
+real frechet_cdf(vector, real[], real)
+real frechet_cdf(vector, real[], vector)
+real frechet_cdf(vector, real[], row_vector)
+real frechet_cdf(vector, real[], real[])
+real frechet_cdf(row_vector, real, real)
+real frechet_cdf(row_vector, real, vector)
+real frechet_cdf(row_vector, real, row_vector)
+real frechet_cdf(row_vector, real, real[])
+real frechet_cdf(row_vector, vector, real)
+real frechet_cdf(row_vector, vector, vector)
+real frechet_cdf(row_vector, vector, row_vector)
+real frechet_cdf(row_vector, vector, real[])
+real frechet_cdf(row_vector, row_vector, real)
+real frechet_cdf(row_vector, row_vector, vector)
+real frechet_cdf(row_vector, row_vector, row_vector)
+real frechet_cdf(row_vector, row_vector, real[])
+real frechet_cdf(row_vector, real[], real)
+real frechet_cdf(row_vector, real[], vector)
+real frechet_cdf(row_vector, real[], row_vector)
+real frechet_cdf(row_vector, real[], real[])
+real frechet_cdf(real[], real, vector)
+real frechet_cdf(real[], real, row_vector)
+real frechet_cdf(real[], vector, real)
+real frechet_cdf(real[], vector, vector)
+real frechet_cdf(real[], vector, row_vector)
+real frechet_cdf(real[], vector, real[])
+real frechet_cdf(real[], row_vector, real)
+real frechet_cdf(real[], row_vector, vector)
+real frechet_cdf(real[], row_vector, row_vector)
+real frechet_cdf(real[], row_vector, real[])
+real frechet_cdf(real[], real[], vector)
+real frechet_cdf(real[], real[], row_vector)
+real frechet_cdf_log(real, real, vector)
+real frechet_cdf_log(real, real, row_vector)
+real frechet_cdf_log(real, vector, real)
+real frechet_cdf_log(real, vector, vector)
+real frechet_cdf_log(real, vector, row_vector)
+real frechet_cdf_log(real, vector, real[])
+real frechet_cdf_log(real, row_vector, real)
+real frechet_cdf_log(real, row_vector, vector)
+real frechet_cdf_log(real, row_vector, row_vector)
+real frechet_cdf_log(real, row_vector, real[])
+real frechet_cdf_log(real, real[], vector)
+real frechet_cdf_log(real, real[], row_vector)
+real frechet_cdf_log(vector, real, real)
+real frechet_cdf_log(vector, real, vector)
+real frechet_cdf_log(vector, real, row_vector)
+real frechet_cdf_log(vector, real, real[])
+real frechet_cdf_log(vector, vector, real)
+real frechet_cdf_log(vector, vector, vector)
+real frechet_cdf_log(vector, vector, row_vector)
+real frechet_cdf_log(vector, vector, real[])
+real frechet_cdf_log(vector, row_vector, real)
+real frechet_cdf_log(vector, row_vector, vector)
+real frechet_cdf_log(vector, row_vector, row_vector)
+real frechet_cdf_log(vector, row_vector, real[])
+real frechet_cdf_log(vector, real[], real)
+real frechet_cdf_log(vector, real[], vector)
+real frechet_cdf_log(vector, real[], row_vector)
+real frechet_cdf_log(vector, real[], real[])
+real frechet_cdf_log(row_vector, real, real)
+real frechet_cdf_log(row_vector, real, vector)
+real frechet_cdf_log(row_vector, real, row_vector)
+real frechet_cdf_log(row_vector, real, real[])
+real frechet_cdf_log(row_vector, vector, real)
+real frechet_cdf_log(row_vector, vector, vector)
+real frechet_cdf_log(row_vector, vector, row_vector)
+real frechet_cdf_log(row_vector, vector, real[])
+real frechet_cdf_log(row_vector, row_vector, real)
+real frechet_cdf_log(row_vector, row_vector, vector)
+real frechet_cdf_log(row_vector, row_vector, row_vector)
+real frechet_cdf_log(row_vector, row_vector, real[])
+real frechet_cdf_log(row_vector, real[], real)
+real frechet_cdf_log(row_vector, real[], vector)
+real frechet_cdf_log(row_vector, real[], row_vector)
+real frechet_cdf_log(row_vector, real[], real[])
+real frechet_cdf_log(real[], real, vector)
+real frechet_cdf_log(real[], real, row_vector)
+real frechet_cdf_log(real[], vector, real)
+real frechet_cdf_log(real[], vector, vector)
+real frechet_cdf_log(real[], vector, row_vector)
+real frechet_cdf_log(real[], vector, real[])
+real frechet_cdf_log(real[], row_vector, real)
+real frechet_cdf_log(real[], row_vector, vector)
+real frechet_cdf_log(real[], row_vector, row_vector)
+real frechet_cdf_log(real[], row_vector, real[])
+real frechet_cdf_log(real[], real[], vector)
+real frechet_cdf_log(real[], real[], row_vector)
+real frechet_lccdf(real, real, vector)
+real frechet_lccdf(real, real, row_vector)
+real frechet_lccdf(real, vector, real)
+real frechet_lccdf(real, vector, vector)
+real frechet_lccdf(real, vector, row_vector)
+real frechet_lccdf(real, vector, real[])
+real frechet_lccdf(real, row_vector, real)
+real frechet_lccdf(real, row_vector, vector)
+real frechet_lccdf(real, row_vector, row_vector)
+real frechet_lccdf(real, row_vector, real[])
+real frechet_lccdf(real, real[], vector)
+real frechet_lccdf(real, real[], row_vector)
+real frechet_lccdf(vector, real, real)
+real frechet_lccdf(vector, real, vector)
+real frechet_lccdf(vector, real, row_vector)
+real frechet_lccdf(vector, real, real[])
+real frechet_lccdf(vector, vector, real)
+real frechet_lccdf(vector, vector, vector)
+real frechet_lccdf(vector, vector, row_vector)
+real frechet_lccdf(vector, vector, real[])
+real frechet_lccdf(vector, row_vector, real)
+real frechet_lccdf(vector, row_vector, vector)
+real frechet_lccdf(vector, row_vector, row_vector)
+real frechet_lccdf(vector, row_vector, real[])
+real frechet_lccdf(vector, real[], real)
+real frechet_lccdf(vector, real[], vector)
+real frechet_lccdf(vector, real[], row_vector)
+real frechet_lccdf(vector, real[], real[])
+real frechet_lccdf(row_vector, real, real)
+real frechet_lccdf(row_vector, real, vector)
+real frechet_lccdf(row_vector, real, row_vector)
+real frechet_lccdf(row_vector, real, real[])
+real frechet_lccdf(row_vector, vector, real)
+real frechet_lccdf(row_vector, vector, vector)
+real frechet_lccdf(row_vector, vector, row_vector)
+real frechet_lccdf(row_vector, vector, real[])
+real frechet_lccdf(row_vector, row_vector, real)
+real frechet_lccdf(row_vector, row_vector, vector)
+real frechet_lccdf(row_vector, row_vector, row_vector)
+real frechet_lccdf(row_vector, row_vector, real[])
+real frechet_lccdf(row_vector, real[], real)
+real frechet_lccdf(row_vector, real[], vector)
+real frechet_lccdf(row_vector, real[], row_vector)
+real frechet_lccdf(row_vector, real[], real[])
+real frechet_lccdf(real[], real, vector)
+real frechet_lccdf(real[], real, row_vector)
+real frechet_lccdf(real[], vector, real)
+real frechet_lccdf(real[], vector, vector)
+real frechet_lccdf(real[], vector, row_vector)
+real frechet_lccdf(real[], vector, real[])
+real frechet_lccdf(real[], row_vector, real)
+real frechet_lccdf(real[], row_vector, vector)
+real frechet_lccdf(real[], row_vector, row_vector)
+real frechet_lccdf(real[], row_vector, real[])
+real frechet_lccdf(real[], real[], vector)
+real frechet_lccdf(real[], real[], row_vector)
+real frechet_lcdf(real, real, vector)
+real frechet_lcdf(real, real, row_vector)
+real frechet_lcdf(real, vector, real)
+real frechet_lcdf(real, vector, vector)
+real frechet_lcdf(real, vector, row_vector)
+real frechet_lcdf(real, vector, real[])
+real frechet_lcdf(real, row_vector, real)
+real frechet_lcdf(real, row_vector, vector)
+real frechet_lcdf(real, row_vector, row_vector)
+real frechet_lcdf(real, row_vector, real[])
+real frechet_lcdf(real, real[], vector)
+real frechet_lcdf(real, real[], row_vector)
+real frechet_lcdf(vector, real, real)
+real frechet_lcdf(vector, real, vector)
+real frechet_lcdf(vector, real, row_vector)
+real frechet_lcdf(vector, real, real[])
+real frechet_lcdf(vector, vector, real)
+real frechet_lcdf(vector, vector, vector)
+real frechet_lcdf(vector, vector, row_vector)
+real frechet_lcdf(vector, vector, real[])
+real frechet_lcdf(vector, row_vector, real)
+real frechet_lcdf(vector, row_vector, vector)
+real frechet_lcdf(vector, row_vector, row_vector)
+real frechet_lcdf(vector, row_vector, real[])
+real frechet_lcdf(vector, real[], real)
+real frechet_lcdf(vector, real[], vector)
+real frechet_lcdf(vector, real[], row_vector)
+real frechet_lcdf(vector, real[], real[])
+real frechet_lcdf(row_vector, real, real)
+real frechet_lcdf(row_vector, real, vector)
+real frechet_lcdf(row_vector, real, row_vector)
+real frechet_lcdf(row_vector, real, real[])
+real frechet_lcdf(row_vector, vector, real)
+real frechet_lcdf(row_vector, vector, vector)
+real frechet_lcdf(row_vector, vector, row_vector)
+real frechet_lcdf(row_vector, vector, real[])
+real frechet_lcdf(row_vector, row_vector, real)
+real frechet_lcdf(row_vector, row_vector, vector)
+real frechet_lcdf(row_vector, row_vector, row_vector)
+real frechet_lcdf(row_vector, row_vector, real[])
+real frechet_lcdf(row_vector, real[], real)
+real frechet_lcdf(row_vector, real[], vector)
+real frechet_lcdf(row_vector, real[], row_vector)
+real frechet_lcdf(row_vector, real[], real[])
+real frechet_lcdf(real[], real, vector)
+real frechet_lcdf(real[], real, row_vector)
+real frechet_lcdf(real[], vector, real)
+real frechet_lcdf(real[], vector, vector)
+real frechet_lcdf(real[], vector, row_vector)
+real frechet_lcdf(real[], vector, real[])
+real frechet_lcdf(real[], row_vector, real)
+real frechet_lcdf(real[], row_vector, vector)
+real frechet_lcdf(real[], row_vector, row_vector)
+real frechet_lcdf(real[], row_vector, real[])
+real frechet_lcdf(real[], real[], vector)
+real frechet_lcdf(real[], real[], row_vector)
+real frechet_log(real, real, vector)
+real frechet_log(real, real, row_vector)
+real frechet_log(real, vector, real)
+real frechet_log(real, vector, vector)
+real frechet_log(real, vector, row_vector)
+real frechet_log(real, vector, real[])
+real frechet_log(real, row_vector, real)
+real frechet_log(real, row_vector, vector)
+real frechet_log(real, row_vector, row_vector)
+real frechet_log(real, row_vector, real[])
+real frechet_log(real, real[], vector)
+real frechet_log(real, real[], row_vector)
+real frechet_log(vector, real, real)
+real frechet_log(vector, real, vector)
+real frechet_log(vector, real, row_vector)
+real frechet_log(vector, real, real[])
+real frechet_log(vector, vector, real)
+real frechet_log(vector, vector, vector)
+real frechet_log(vector, vector, row_vector)
+real frechet_log(vector, vector, real[])
+real frechet_log(vector, row_vector, real)
+real frechet_log(vector, row_vector, vector)
+real frechet_log(vector, row_vector, row_vector)
+real frechet_log(vector, row_vector, real[])
+real frechet_log(vector, real[], real)
+real frechet_log(vector, real[], vector)
+real frechet_log(vector, real[], row_vector)
+real frechet_log(vector, real[], real[])
+real frechet_log(row_vector, real, real)
+real frechet_log(row_vector, real, vector)
+real frechet_log(row_vector, real, row_vector)
+real frechet_log(row_vector, real, real[])
+real frechet_log(row_vector, vector, real)
+real frechet_log(row_vector, vector, vector)
+real frechet_log(row_vector, vector, row_vector)
+real frechet_log(row_vector, vector, real[])
+real frechet_log(row_vector, row_vector, real)
+real frechet_log(row_vector, row_vector, vector)
+real frechet_log(row_vector, row_vector, row_vector)
+real frechet_log(row_vector, row_vector, real[])
+real frechet_log(row_vector, real[], real)
+real frechet_log(row_vector, real[], vector)
+real frechet_log(row_vector, real[], row_vector)
+real frechet_log(row_vector, real[], real[])
+real frechet_log(real[], real, vector)
+real frechet_log(real[], real, row_vector)
+real frechet_log(real[], vector, real)
+real frechet_log(real[], vector, vector)
+real frechet_log(real[], vector, row_vector)
+real frechet_log(real[], vector, real[])
+real frechet_log(real[], row_vector, real)
+real frechet_log(real[], row_vector, vector)
+real frechet_log(real[], row_vector, row_vector)
+real frechet_log(real[], row_vector, real[])
+real frechet_log(real[], real[], vector)
+real frechet_log(real[], real[], row_vector)
+real frechet_lpdf(real, real, vector)
+real frechet_lpdf(real, real, row_vector)
+real frechet_lpdf(real, vector, real)
+real frechet_lpdf(real, vector, vector)
+real frechet_lpdf(real, vector, row_vector)
+real frechet_lpdf(real, vector, real[])
+real frechet_lpdf(real, row_vector, real)
+real frechet_lpdf(real, row_vector, vector)
+real frechet_lpdf(real, row_vector, row_vector)
+real frechet_lpdf(real, row_vector, real[])
+real frechet_lpdf(real, real[], vector)
+real frechet_lpdf(real, real[], row_vector)
+real frechet_lpdf(vector, real, real)
+real frechet_lpdf(vector, real, vector)
+real frechet_lpdf(vector, real, row_vector)
+real frechet_lpdf(vector, real, real[])
+real frechet_lpdf(vector, vector, real)
+real frechet_lpdf(vector, vector, vector)
+real frechet_lpdf(vector, vector, row_vector)
+real frechet_lpdf(vector, vector, real[])
+real frechet_lpdf(vector, row_vector, real)
+real frechet_lpdf(vector, row_vector, vector)
+real frechet_lpdf(vector, row_vector, row_vector)
+real frechet_lpdf(vector, row_vector, real[])
+real frechet_lpdf(vector, real[], real)
+real frechet_lpdf(vector, real[], vector)
+real frechet_lpdf(vector, real[], row_vector)
+real frechet_lpdf(vector, real[], real[])
+real frechet_lpdf(row_vector, real, real)
+real frechet_lpdf(row_vector, real, vector)
+real frechet_lpdf(row_vector, real, row_vector)
+real frechet_lpdf(row_vector, real, real[])
+real frechet_lpdf(row_vector, vector, real)
+real frechet_lpdf(row_vector, vector, vector)
+real frechet_lpdf(row_vector, vector, row_vector)
+real frechet_lpdf(row_vector, vector, real[])
+real frechet_lpdf(row_vector, row_vector, real)
+real frechet_lpdf(row_vector, row_vector, vector)
+real frechet_lpdf(row_vector, row_vector, row_vector)
+real frechet_lpdf(row_vector, row_vector, real[])
+real frechet_lpdf(row_vector, real[], real)
+real frechet_lpdf(row_vector, real[], vector)
+real frechet_lpdf(row_vector, real[], row_vector)
+real frechet_lpdf(row_vector, real[], real[])
+real frechet_lpdf(real[], real, vector)
+real frechet_lpdf(real[], real, row_vector)
+real frechet_lpdf(real[], vector, real)
+real frechet_lpdf(real[], vector, vector)
+real frechet_lpdf(real[], vector, row_vector)
+real frechet_lpdf(real[], vector, real[])
+real frechet_lpdf(real[], row_vector, real)
+real frechet_lpdf(real[], row_vector, vector)
+real frechet_lpdf(real[], row_vector, row_vector)
+real frechet_lpdf(real[], row_vector, real[])
+real frechet_lpdf(real[], real[], vector)
+real frechet_lpdf(real[], real[], row_vector)
+real[] frechet_rng(int, vector)
+real[] frechet_rng(int, row_vector)
+real[] frechet_rng(real, vector)
+real[] frechet_rng(real, row_vector)
+real[] frechet_rng(vector, int)
+real[] frechet_rng(vector, real)
+real[] frechet_rng(vector, vector)
+real[] frechet_rng(vector, row_vector)
+real[] frechet_rng(vector, int[])
+real[] frechet_rng(vector, real[])
+real[] frechet_rng(row_vector, int)
+real[] frechet_rng(row_vector, real)
+real[] frechet_rng(row_vector, vector)
+real[] frechet_rng(row_vector, row_vector)
+real[] frechet_rng(row_vector, int[])
+real[] frechet_rng(row_vector, real[])
+real[] frechet_rng(int[], vector)
+real[] frechet_rng(int[], row_vector)
+real[] frechet_rng(real[], vector)
+real[] frechet_rng(real[], row_vector)
+real gamma_ccdf_log(real, real, vector)
+real gamma_ccdf_log(real, real, row_vector)
+real gamma_ccdf_log(real, vector, real)
+real gamma_ccdf_log(real, vector, vector)
+real gamma_ccdf_log(real, vector, row_vector)
+real gamma_ccdf_log(real, vector, real[])
+real gamma_ccdf_log(real, row_vector, real)
+real gamma_ccdf_log(real, row_vector, vector)
+real gamma_ccdf_log(real, row_vector, row_vector)
+real gamma_ccdf_log(real, row_vector, real[])
+real gamma_ccdf_log(real, real[], vector)
+real gamma_ccdf_log(real, real[], row_vector)
+real gamma_ccdf_log(vector, real, real)
+real gamma_ccdf_log(vector, real, vector)
+real gamma_ccdf_log(vector, real, row_vector)
+real gamma_ccdf_log(vector, real, real[])
+real gamma_ccdf_log(vector, vector, real)
+real gamma_ccdf_log(vector, vector, vector)
+real gamma_ccdf_log(vector, vector, row_vector)
+real gamma_ccdf_log(vector, vector, real[])
+real gamma_ccdf_log(vector, row_vector, real)
+real gamma_ccdf_log(vector, row_vector, vector)
+real gamma_ccdf_log(vector, row_vector, row_vector)
+real gamma_ccdf_log(vector, row_vector, real[])
+real gamma_ccdf_log(vector, real[], real)
+real gamma_ccdf_log(vector, real[], vector)
+real gamma_ccdf_log(vector, real[], row_vector)
+real gamma_ccdf_log(vector, real[], real[])
+real gamma_ccdf_log(row_vector, real, real)
+real gamma_ccdf_log(row_vector, real, vector)
+real gamma_ccdf_log(row_vector, real, row_vector)
+real gamma_ccdf_log(row_vector, real, real[])
+real gamma_ccdf_log(row_vector, vector, real)
+real gamma_ccdf_log(row_vector, vector, vector)
+real gamma_ccdf_log(row_vector, vector, row_vector)
+real gamma_ccdf_log(row_vector, vector, real[])
+real gamma_ccdf_log(row_vector, row_vector, real)
+real gamma_ccdf_log(row_vector, row_vector, vector)
+real gamma_ccdf_log(row_vector, row_vector, row_vector)
+real gamma_ccdf_log(row_vector, row_vector, real[])
+real gamma_ccdf_log(row_vector, real[], real)
+real gamma_ccdf_log(row_vector, real[], vector)
+real gamma_ccdf_log(row_vector, real[], row_vector)
+real gamma_ccdf_log(row_vector, real[], real[])
+real gamma_ccdf_log(real[], real, vector)
+real gamma_ccdf_log(real[], real, row_vector)
+real gamma_ccdf_log(real[], vector, real)
+real gamma_ccdf_log(real[], vector, vector)
+real gamma_ccdf_log(real[], vector, row_vector)
+real gamma_ccdf_log(real[], vector, real[])
+real gamma_ccdf_log(real[], row_vector, real)
+real gamma_ccdf_log(real[], row_vector, vector)
+real gamma_ccdf_log(real[], row_vector, row_vector)
+real gamma_ccdf_log(real[], row_vector, real[])
+real gamma_ccdf_log(real[], real[], vector)
+real gamma_ccdf_log(real[], real[], row_vector)
+real gamma_cdf(real, real, vector)
+real gamma_cdf(real, real, row_vector)
+real gamma_cdf(real, vector, real)
+real gamma_cdf(real, vector, vector)
+real gamma_cdf(real, vector, row_vector)
+real gamma_cdf(real, vector, real[])
+real gamma_cdf(real, row_vector, real)
+real gamma_cdf(real, row_vector, vector)
+real gamma_cdf(real, row_vector, row_vector)
+real gamma_cdf(real, row_vector, real[])
+real gamma_cdf(real, real[], vector)
+real gamma_cdf(real, real[], row_vector)
+real gamma_cdf(vector, real, real)
+real gamma_cdf(vector, real, vector)
+real gamma_cdf(vector, real, row_vector)
+real gamma_cdf(vector, real, real[])
+real gamma_cdf(vector, vector, real)
+real gamma_cdf(vector, vector, vector)
+real gamma_cdf(vector, vector, row_vector)
+real gamma_cdf(vector, vector, real[])
+real gamma_cdf(vector, row_vector, real)
+real gamma_cdf(vector, row_vector, vector)
+real gamma_cdf(vector, row_vector, row_vector)
+real gamma_cdf(vector, row_vector, real[])
+real gamma_cdf(vector, real[], real)
+real gamma_cdf(vector, real[], vector)
+real gamma_cdf(vector, real[], row_vector)
+real gamma_cdf(vector, real[], real[])
+real gamma_cdf(row_vector, real, real)
+real gamma_cdf(row_vector, real, vector)
+real gamma_cdf(row_vector, real, row_vector)
+real gamma_cdf(row_vector, real, real[])
+real gamma_cdf(row_vector, vector, real)
+real gamma_cdf(row_vector, vector, vector)
+real gamma_cdf(row_vector, vector, row_vector)
+real gamma_cdf(row_vector, vector, real[])
+real gamma_cdf(row_vector, row_vector, real)
+real gamma_cdf(row_vector, row_vector, vector)
+real gamma_cdf(row_vector, row_vector, row_vector)
+real gamma_cdf(row_vector, row_vector, real[])
+real gamma_cdf(row_vector, real[], real)
+real gamma_cdf(row_vector, real[], vector)
+real gamma_cdf(row_vector, real[], row_vector)
+real gamma_cdf(row_vector, real[], real[])
+real gamma_cdf(real[], real, vector)
+real gamma_cdf(real[], real, row_vector)
+real gamma_cdf(real[], vector, real)
+real gamma_cdf(real[], vector, vector)
+real gamma_cdf(real[], vector, row_vector)
+real gamma_cdf(real[], vector, real[])
+real gamma_cdf(real[], row_vector, real)
+real gamma_cdf(real[], row_vector, vector)
+real gamma_cdf(real[], row_vector, row_vector)
+real gamma_cdf(real[], row_vector, real[])
+real gamma_cdf(real[], real[], vector)
+real gamma_cdf(real[], real[], row_vector)
+real gamma_cdf_log(real, real, vector)
+real gamma_cdf_log(real, real, row_vector)
+real gamma_cdf_log(real, vector, real)
+real gamma_cdf_log(real, vector, vector)
+real gamma_cdf_log(real, vector, row_vector)
+real gamma_cdf_log(real, vector, real[])
+real gamma_cdf_log(real, row_vector, real)
+real gamma_cdf_log(real, row_vector, vector)
+real gamma_cdf_log(real, row_vector, row_vector)
+real gamma_cdf_log(real, row_vector, real[])
+real gamma_cdf_log(real, real[], vector)
+real gamma_cdf_log(real, real[], row_vector)
+real gamma_cdf_log(vector, real, real)
+real gamma_cdf_log(vector, real, vector)
+real gamma_cdf_log(vector, real, row_vector)
+real gamma_cdf_log(vector, real, real[])
+real gamma_cdf_log(vector, vector, real)
+real gamma_cdf_log(vector, vector, vector)
+real gamma_cdf_log(vector, vector, row_vector)
+real gamma_cdf_log(vector, vector, real[])
+real gamma_cdf_log(vector, row_vector, real)
+real gamma_cdf_log(vector, row_vector, vector)
+real gamma_cdf_log(vector, row_vector, row_vector)
+real gamma_cdf_log(vector, row_vector, real[])
+real gamma_cdf_log(vector, real[], real)
+real gamma_cdf_log(vector, real[], vector)
+real gamma_cdf_log(vector, real[], row_vector)
+real gamma_cdf_log(vector, real[], real[])
+real gamma_cdf_log(row_vector, real, real)
+real gamma_cdf_log(row_vector, real, vector)
+real gamma_cdf_log(row_vector, real, row_vector)
+real gamma_cdf_log(row_vector, real, real[])
+real gamma_cdf_log(row_vector, vector, real)
+real gamma_cdf_log(row_vector, vector, vector)
+real gamma_cdf_log(row_vector, vector, row_vector)
+real gamma_cdf_log(row_vector, vector, real[])
+real gamma_cdf_log(row_vector, row_vector, real)
+real gamma_cdf_log(row_vector, row_vector, vector)
+real gamma_cdf_log(row_vector, row_vector, row_vector)
+real gamma_cdf_log(row_vector, row_vector, real[])
+real gamma_cdf_log(row_vector, real[], real)
+real gamma_cdf_log(row_vector, real[], vector)
+real gamma_cdf_log(row_vector, real[], row_vector)
+real gamma_cdf_log(row_vector, real[], real[])
+real gamma_cdf_log(real[], real, vector)
+real gamma_cdf_log(real[], real, row_vector)
+real gamma_cdf_log(real[], real, real[])
+real gamma_cdf_log(real[], vector, real)
+real gamma_cdf_log(real[], vector, vector)
+real gamma_cdf_log(real[], vector, row_vector)
+real gamma_cdf_log(real[], vector, real[])
+real gamma_cdf_log(real[], row_vector, real)
+real gamma_cdf_log(real[], row_vector, vector)
+real gamma_cdf_log(real[], row_vector, row_vector)
+real gamma_cdf_log(real[], row_vector, real[])
+real gamma_cdf_log(real[], real[], vector)
+real gamma_cdf_log(real[], real[], row_vector)
+real gamma_lccdf(real, real, vector)
+real gamma_lccdf(real, real, row_vector)
+real gamma_lccdf(real, vector, real)
+real gamma_lccdf(real, vector, vector)
+real gamma_lccdf(real, vector, row_vector)
+real gamma_lccdf(real, vector, real[])
+real gamma_lccdf(real, row_vector, real)
+real gamma_lccdf(real, row_vector, vector)
+real gamma_lccdf(real, row_vector, row_vector)
+real gamma_lccdf(real, row_vector, real[])
+real gamma_lccdf(real, real[], vector)
+real gamma_lccdf(real, real[], row_vector)
+real gamma_lccdf(vector, real, real)
+real gamma_lccdf(vector, real, vector)
+real gamma_lccdf(vector, real, row_vector)
+real gamma_lccdf(vector, real, real[])
+real gamma_lccdf(vector, vector, real)
+real gamma_lccdf(vector, vector, vector)
+real gamma_lccdf(vector, vector, row_vector)
+real gamma_lccdf(vector, vector, real[])
+real gamma_lccdf(vector, row_vector, real)
+real gamma_lccdf(vector, row_vector, vector)
+real gamma_lccdf(vector, row_vector, row_vector)
+real gamma_lccdf(vector, row_vector, real[])
+real gamma_lccdf(vector, real[], real)
+real gamma_lccdf(vector, real[], vector)
+real gamma_lccdf(vector, real[], row_vector)
+real gamma_lccdf(vector, real[], real[])
+real gamma_lccdf(row_vector, real, real)
+real gamma_lccdf(row_vector, real, vector)
+real gamma_lccdf(row_vector, real, row_vector)
+real gamma_lccdf(row_vector, real, real[])
+real gamma_lccdf(row_vector, vector, real)
+real gamma_lccdf(row_vector, vector, vector)
+real gamma_lccdf(row_vector, vector, row_vector)
+real gamma_lccdf(row_vector, vector, real[])
+real gamma_lccdf(row_vector, row_vector, real)
+real gamma_lccdf(row_vector, row_vector, vector)
+real gamma_lccdf(row_vector, row_vector, row_vector)
+real gamma_lccdf(row_vector, row_vector, real[])
+real gamma_lccdf(row_vector, real[], real)
+real gamma_lccdf(row_vector, real[], vector)
+real gamma_lccdf(row_vector, real[], row_vector)
+real gamma_lccdf(row_vector, real[], real[])
+real gamma_lccdf(real[], real, vector)
+real gamma_lccdf(real[], real, row_vector)
+real gamma_lccdf(real[], vector, real)
+real gamma_lccdf(real[], vector, vector)
+real gamma_lccdf(real[], vector, row_vector)
+real gamma_lccdf(real[], vector, real[])
+real gamma_lccdf(real[], row_vector, real)
+real gamma_lccdf(real[], row_vector, vector)
+real gamma_lccdf(real[], row_vector, row_vector)
+real gamma_lccdf(real[], row_vector, real[])
+real gamma_lccdf(real[], real[], vector)
+real gamma_lccdf(real[], real[], row_vector)
+real gamma_lcdf(real, real, vector)
+real gamma_lcdf(real, real, row_vector)
+real gamma_lcdf(real, vector, real)
+real gamma_lcdf(real, vector, vector)
+real gamma_lcdf(real, vector, row_vector)
+real gamma_lcdf(real, vector, real[])
+real gamma_lcdf(real, row_vector, real)
+real gamma_lcdf(real, row_vector, vector)
+real gamma_lcdf(real, row_vector, row_vector)
+real gamma_lcdf(real, row_vector, real[])
+real gamma_lcdf(real, real[], vector)
+real gamma_lcdf(real, real[], row_vector)
+real gamma_lcdf(vector, real, real)
+real gamma_lcdf(vector, real, vector)
+real gamma_lcdf(vector, real, row_vector)
+real gamma_lcdf(vector, real, real[])
+real gamma_lcdf(vector, vector, real)
+real gamma_lcdf(vector, vector, vector)
+real gamma_lcdf(vector, vector, row_vector)
+real gamma_lcdf(vector, vector, real[])
+real gamma_lcdf(vector, row_vector, real)
+real gamma_lcdf(vector, row_vector, vector)
+real gamma_lcdf(vector, row_vector, row_vector)
+real gamma_lcdf(vector, row_vector, real[])
+real gamma_lcdf(vector, real[], real)
+real gamma_lcdf(vector, real[], vector)
+real gamma_lcdf(vector, real[], row_vector)
+real gamma_lcdf(vector, real[], real[])
+real gamma_lcdf(row_vector, real, real)
+real gamma_lcdf(row_vector, real, vector)
+real gamma_lcdf(row_vector, real, row_vector)
+real gamma_lcdf(row_vector, real, real[])
+real gamma_lcdf(row_vector, vector, real)
+real gamma_lcdf(row_vector, vector, vector)
+real gamma_lcdf(row_vector, vector, row_vector)
+real gamma_lcdf(row_vector, vector, real[])
+real gamma_lcdf(row_vector, row_vector, real)
+real gamma_lcdf(row_vector, row_vector, vector)
+real gamma_lcdf(row_vector, row_vector, row_vector)
+real gamma_lcdf(row_vector, row_vector, real[])
+real gamma_lcdf(row_vector, real[], real)
+real gamma_lcdf(row_vector, real[], vector)
+real gamma_lcdf(row_vector, real[], row_vector)
+real gamma_lcdf(row_vector, real[], real[])
+real gamma_lcdf(real[], real, vector)
+real gamma_lcdf(real[], real, row_vector)
+real gamma_lcdf(real[], vector, real)
+real gamma_lcdf(real[], vector, vector)
+real gamma_lcdf(real[], vector, row_vector)
+real gamma_lcdf(real[], vector, real[])
+real gamma_lcdf(real[], row_vector, real)
+real gamma_lcdf(real[], row_vector, vector)
+real gamma_lcdf(real[], row_vector, row_vector)
+real gamma_lcdf(real[], row_vector, real[])
+real gamma_lcdf(real[], real[], vector)
+real gamma_lcdf(real[], real[], row_vector)
+real gamma_log(real, real, vector)
+real gamma_log(real, real, row_vector)
+real gamma_log(real, vector, real)
+real gamma_log(real, vector, vector)
+real gamma_log(real, vector, row_vector)
+real gamma_log(real, vector, real[])
+real gamma_log(real, row_vector, real)
+real gamma_log(real, row_vector, vector)
+real gamma_log(real, row_vector, row_vector)
+real gamma_log(real, row_vector, real[])
+real gamma_log(real, real[], vector)
+real gamma_log(real, real[], row_vector)
+real gamma_log(vector, real, real)
+real gamma_log(vector, real, vector)
+real gamma_log(vector, real, row_vector)
+real gamma_log(vector, real, real[])
+real gamma_log(vector, vector, real)
+real gamma_log(vector, vector, vector)
+real gamma_log(vector, vector, row_vector)
+real gamma_log(vector, vector, real[])
+real gamma_log(vector, row_vector, real)
+real gamma_log(vector, row_vector, vector)
+real gamma_log(vector, row_vector, row_vector)
+real gamma_log(vector, row_vector, real[])
+real gamma_log(vector, real[], real)
+real gamma_log(vector, real[], vector)
+real gamma_log(vector, real[], row_vector)
+real gamma_log(vector, real[], real[])
+real gamma_log(row_vector, real, real)
+real gamma_log(row_vector, real, vector)
+real gamma_log(row_vector, real, row_vector)
+real gamma_log(row_vector, real, real[])
+real gamma_log(row_vector, vector, real)
+real gamma_log(row_vector, vector, vector)
+real gamma_log(row_vector, vector, row_vector)
+real gamma_log(row_vector, vector, real[])
+real gamma_log(row_vector, row_vector, real)
+real gamma_log(row_vector, row_vector, vector)
+real gamma_log(row_vector, row_vector, row_vector)
+real gamma_log(row_vector, row_vector, real[])
+real gamma_log(row_vector, real[], real)
+real gamma_log(row_vector, real[], vector)
+real gamma_log(row_vector, real[], row_vector)
+real gamma_log(row_vector, real[], real[])
+real gamma_log(real[], real, vector)
+real gamma_log(real[], real, row_vector)
+real gamma_log(real[], real, real[])
+real gamma_log(real[], vector, real)
+real gamma_log(real[], vector, vector)
+real gamma_log(real[], vector, row_vector)
+real gamma_log(real[], vector, real[])
+real gamma_log(real[], row_vector, real)
+real gamma_log(real[], row_vector, vector)
+real gamma_log(real[], row_vector, row_vector)
+real gamma_log(real[], row_vector, real[])
+real gamma_log(real[], real[], vector)
+real gamma_log(real[], real[], row_vector)
+real gamma_lpdf(real, real, vector)
+real gamma_lpdf(real, real, row_vector)
+real gamma_lpdf(real, vector, real)
+real gamma_lpdf(real, vector, vector)
+real gamma_lpdf(real, vector, row_vector)
+real gamma_lpdf(real, vector, real[])
+real gamma_lpdf(real, row_vector, real)
+real gamma_lpdf(real, row_vector, vector)
+real gamma_lpdf(real, row_vector, row_vector)
+real gamma_lpdf(real, row_vector, real[])
+real gamma_lpdf(real, real[], vector)
+real gamma_lpdf(real, real[], row_vector)
+real gamma_lpdf(vector, real, real)
+real gamma_lpdf(vector, real, vector)
+real gamma_lpdf(vector, real, row_vector)
+real gamma_lpdf(vector, real, real[])
+real gamma_lpdf(vector, vector, real)
+real gamma_lpdf(vector, vector, vector)
+real gamma_lpdf(vector, vector, row_vector)
+real gamma_lpdf(vector, vector, real[])
+real gamma_lpdf(vector, row_vector, real)
+real gamma_lpdf(vector, row_vector, vector)
+real gamma_lpdf(vector, row_vector, row_vector)
+real gamma_lpdf(vector, row_vector, real[])
+real gamma_lpdf(vector, real[], real)
+real gamma_lpdf(vector, real[], vector)
+real gamma_lpdf(vector, real[], row_vector)
+real gamma_lpdf(vector, real[], real[])
+real gamma_lpdf(row_vector, real, real)
+real gamma_lpdf(row_vector, real, vector)
+real gamma_lpdf(row_vector, real, row_vector)
+real gamma_lpdf(row_vector, real, real[])
+real gamma_lpdf(row_vector, vector, real)
+real gamma_lpdf(row_vector, vector, vector)
+real gamma_lpdf(row_vector, vector, row_vector)
+real gamma_lpdf(row_vector, vector, real[])
+real gamma_lpdf(row_vector, row_vector, real)
+real gamma_lpdf(row_vector, row_vector, vector)
+real gamma_lpdf(row_vector, row_vector, row_vector)
+real gamma_lpdf(row_vector, row_vector, real[])
+real gamma_lpdf(row_vector, real[], real)
+real gamma_lpdf(row_vector, real[], vector)
+real gamma_lpdf(row_vector, real[], row_vector)
+real gamma_lpdf(row_vector, real[], real[])
+real gamma_lpdf(real[], real, vector)
+real gamma_lpdf(real[], real, row_vector)
+real gamma_lpdf(real[], vector, real)
+real gamma_lpdf(real[], vector, vector)
+real gamma_lpdf(real[], vector, row_vector)
+real gamma_lpdf(real[], vector, real[])
+real gamma_lpdf(real[], row_vector, real)
+real gamma_lpdf(real[], row_vector, vector)
+real gamma_lpdf(real[], row_vector, row_vector)
+real gamma_lpdf(real[], row_vector, real[])
+real gamma_lpdf(real[], real[], vector)
+real gamma_lpdf(real[], real[], row_vector)
+real[] gamma_rng(int, vector)
+real[] gamma_rng(int, row_vector)
+real[] gamma_rng(real, vector)
+real[] gamma_rng(real, row_vector)
+real[] gamma_rng(vector, int)
+real[] gamma_rng(vector, real)
+real[] gamma_rng(vector, vector)
+real[] gamma_rng(vector, row_vector)
+real[] gamma_rng(vector, int[])
+real[] gamma_rng(vector, real[])
+real[] gamma_rng(row_vector, int)
+real[] gamma_rng(row_vector, real)
+real[] gamma_rng(row_vector, vector)
+real[] gamma_rng(row_vector, row_vector)
+real[] gamma_rng(row_vector, int[])
+real[] gamma_rng(row_vector, real[])
+real[] gamma_rng(int[], vector)
+real[] gamma_rng(int[], row_vector)
+real[] gamma_rng(real[], vector)
+real[] gamma_rng(real[], row_vector)
+real gaussian_dlm_obs_log(matrix, matrix, matrix, vector, matrix, vector,
+                            matrix)
+real gaussian_dlm_obs_log(matrix, matrix, matrix, matrix, matrix, vector,
+                            matrix)
+real gaussian_dlm_obs_lpdf(matrix, matrix, matrix, vector, matrix, vector,
+                             matrix)
+real gaussian_dlm_obs_lpdf(matrix, matrix, matrix, matrix, matrix, vector,
+                             matrix)
+real gumbel_ccdf_log(real, real, vector)
+real gumbel_ccdf_log(real, real, row_vector)
+real gumbel_ccdf_log(real, vector, real)
+real gumbel_ccdf_log(real, vector, vector)
+real gumbel_ccdf_log(real, vector, row_vector)
+real gumbel_ccdf_log(real, vector, real[])
+real gumbel_ccdf_log(real, row_vector, real)
+real gumbel_ccdf_log(real, row_vector, vector)
+real gumbel_ccdf_log(real, row_vector, row_vector)
+real gumbel_ccdf_log(real, row_vector, real[])
+real gumbel_ccdf_log(real, real[], vector)
+real gumbel_ccdf_log(real, real[], row_vector)
+real gumbel_ccdf_log(vector, real, real)
+real gumbel_ccdf_log(vector, real, vector)
+real gumbel_ccdf_log(vector, real, row_vector)
+real gumbel_ccdf_log(vector, real, real[])
+real gumbel_ccdf_log(vector, vector, real)
+real gumbel_ccdf_log(vector, vector, vector)
+real gumbel_ccdf_log(vector, vector, row_vector)
+real gumbel_ccdf_log(vector, vector, real[])
+real gumbel_ccdf_log(vector, row_vector, real)
+real gumbel_ccdf_log(vector, row_vector, vector)
+real gumbel_ccdf_log(vector, row_vector, row_vector)
+real gumbel_ccdf_log(vector, row_vector, real[])
+real gumbel_ccdf_log(vector, real[], real)
+real gumbel_ccdf_log(vector, real[], vector)
+real gumbel_ccdf_log(vector, real[], row_vector)
+real gumbel_ccdf_log(vector, real[], real[])
+real gumbel_ccdf_log(row_vector, real, real)
+real gumbel_ccdf_log(row_vector, real, vector)
+real gumbel_ccdf_log(row_vector, real, row_vector)
+real gumbel_ccdf_log(row_vector, real, real[])
+real gumbel_ccdf_log(row_vector, vector, real)
+real gumbel_ccdf_log(row_vector, vector, vector)
+real gumbel_ccdf_log(row_vector, vector, row_vector)
+real gumbel_ccdf_log(row_vector, vector, real[])
+real gumbel_ccdf_log(row_vector, row_vector, real)
+real gumbel_ccdf_log(row_vector, row_vector, vector)
+real gumbel_ccdf_log(row_vector, row_vector, row_vector)
+real gumbel_ccdf_log(row_vector, row_vector, real[])
+real gumbel_ccdf_log(row_vector, real[], real)
+real gumbel_ccdf_log(row_vector, real[], vector)
+real gumbel_ccdf_log(row_vector, real[], row_vector)
+real gumbel_ccdf_log(row_vector, real[], real[])
+real gumbel_ccdf_log(real[], real, vector)
+real gumbel_ccdf_log(real[], real, row_vector)
+real gumbel_ccdf_log(real[], vector, real)
+real gumbel_ccdf_log(real[], vector, vector)
+real gumbel_ccdf_log(real[], vector, row_vector)
+real gumbel_ccdf_log(real[], vector, real[])
+real gumbel_ccdf_log(real[], row_vector, real)
+real gumbel_ccdf_log(real[], row_vector, vector)
+real gumbel_ccdf_log(real[], row_vector, row_vector)
+real gumbel_ccdf_log(real[], row_vector, real[])
+real gumbel_ccdf_log(real[], real[], vector)
+real gumbel_ccdf_log(real[], real[], row_vector)
+real gumbel_cdf(real, real, vector)
+real gumbel_cdf(real, real, row_vector)
+real gumbel_cdf(real, vector, real)
+real gumbel_cdf(real, vector, vector)
+real gumbel_cdf(real, vector, row_vector)
+real gumbel_cdf(real, vector, real[])
+real gumbel_cdf(real, row_vector, real)
+real gumbel_cdf(real, row_vector, vector)
+real gumbel_cdf(real, row_vector, row_vector)
+real gumbel_cdf(real, row_vector, real[])
+real gumbel_cdf(real, real[], vector)
+real gumbel_cdf(real, real[], row_vector)
+real gumbel_cdf(vector, real, real)
+real gumbel_cdf(vector, real, vector)
+real gumbel_cdf(vector, real, row_vector)
+real gumbel_cdf(vector, real, real[])
+real gumbel_cdf(vector, vector, real)
+real gumbel_cdf(vector, vector, vector)
+real gumbel_cdf(vector, vector, row_vector)
+real gumbel_cdf(vector, vector, real[])
+real gumbel_cdf(vector, row_vector, real)
+real gumbel_cdf(vector, row_vector, vector)
+real gumbel_cdf(vector, row_vector, row_vector)
+real gumbel_cdf(vector, row_vector, real[])
+real gumbel_cdf(vector, real[], real)
+real gumbel_cdf(vector, real[], vector)
+real gumbel_cdf(vector, real[], row_vector)
+real gumbel_cdf(vector, real[], real[])
+real gumbel_cdf(row_vector, real, real)
+real gumbel_cdf(row_vector, real, vector)
+real gumbel_cdf(row_vector, real, row_vector)
+real gumbel_cdf(row_vector, real, real[])
+real gumbel_cdf(row_vector, vector, real)
+real gumbel_cdf(row_vector, vector, vector)
+real gumbel_cdf(row_vector, vector, row_vector)
+real gumbel_cdf(row_vector, vector, real[])
+real gumbel_cdf(row_vector, row_vector, real)
+real gumbel_cdf(row_vector, row_vector, vector)
+real gumbel_cdf(row_vector, row_vector, row_vector)
+real gumbel_cdf(row_vector, row_vector, real[])
+real gumbel_cdf(row_vector, real[], real)
+real gumbel_cdf(row_vector, real[], vector)
+real gumbel_cdf(row_vector, real[], row_vector)
+real gumbel_cdf(row_vector, real[], real[])
+real gumbel_cdf(real[], real, vector)
+real gumbel_cdf(real[], real, row_vector)
+real gumbel_cdf(real[], vector, real)
+real gumbel_cdf(real[], vector, vector)
+real gumbel_cdf(real[], vector, row_vector)
+real gumbel_cdf(real[], vector, real[])
+real gumbel_cdf(real[], row_vector, real)
+real gumbel_cdf(real[], row_vector, vector)
+real gumbel_cdf(real[], row_vector, row_vector)
+real gumbel_cdf(real[], row_vector, real[])
+real gumbel_cdf(real[], real[], vector)
+real gumbel_cdf(real[], real[], row_vector)
+real gumbel_cdf_log(real, real, vector)
+real gumbel_cdf_log(real, real, row_vector)
+real gumbel_cdf_log(real, vector, real)
+real gumbel_cdf_log(real, vector, vector)
+real gumbel_cdf_log(real, vector, row_vector)
+real gumbel_cdf_log(real, vector, real[])
+real gumbel_cdf_log(real, row_vector, real)
+real gumbel_cdf_log(real, row_vector, vector)
+real gumbel_cdf_log(real, row_vector, row_vector)
+real gumbel_cdf_log(real, row_vector, real[])
+real gumbel_cdf_log(real, real[], vector)
+real gumbel_cdf_log(real, real[], row_vector)
+real gumbel_cdf_log(vector, real, real)
+real gumbel_cdf_log(vector, real, vector)
+real gumbel_cdf_log(vector, real, row_vector)
+real gumbel_cdf_log(vector, real, real[])
+real gumbel_cdf_log(vector, vector, real)
+real gumbel_cdf_log(vector, vector, vector)
+real gumbel_cdf_log(vector, vector, row_vector)
+real gumbel_cdf_log(vector, vector, real[])
+real gumbel_cdf_log(vector, row_vector, real)
+real gumbel_cdf_log(vector, row_vector, vector)
+real gumbel_cdf_log(vector, row_vector, row_vector)
+real gumbel_cdf_log(vector, row_vector, real[])
+real gumbel_cdf_log(vector, real[], real)
+real gumbel_cdf_log(vector, real[], vector)
+real gumbel_cdf_log(vector, real[], row_vector)
+real gumbel_cdf_log(vector, real[], real[])
+real gumbel_cdf_log(row_vector, real, real)
+real gumbel_cdf_log(row_vector, real, vector)
+real gumbel_cdf_log(row_vector, real, row_vector)
+real gumbel_cdf_log(row_vector, real, real[])
+real gumbel_cdf_log(row_vector, vector, real)
+real gumbel_cdf_log(row_vector, vector, vector)
+real gumbel_cdf_log(row_vector, vector, row_vector)
+real gumbel_cdf_log(row_vector, vector, real[])
+real gumbel_cdf_log(row_vector, row_vector, real)
+real gumbel_cdf_log(row_vector, row_vector, vector)
+real gumbel_cdf_log(row_vector, row_vector, row_vector)
+real gumbel_cdf_log(row_vector, row_vector, real[])
+real gumbel_cdf_log(row_vector, real[], real)
+real gumbel_cdf_log(row_vector, real[], vector)
+real gumbel_cdf_log(row_vector, real[], row_vector)
+real gumbel_cdf_log(row_vector, real[], real[])
+real gumbel_cdf_log(real[], real, vector)
+real gumbel_cdf_log(real[], real, row_vector)
+real gumbel_cdf_log(real[], vector, real)
+real gumbel_cdf_log(real[], vector, vector)
+real gumbel_cdf_log(real[], vector, row_vector)
+real gumbel_cdf_log(real[], vector, real[])
+real gumbel_cdf_log(real[], row_vector, real)
+real gumbel_cdf_log(real[], row_vector, vector)
+real gumbel_cdf_log(real[], row_vector, row_vector)
+real gumbel_cdf_log(real[], row_vector, real[])
+real gumbel_cdf_log(real[], real[], vector)
+real gumbel_cdf_log(real[], real[], row_vector)
+real gumbel_lccdf(real, real, vector)
+real gumbel_lccdf(real, real, row_vector)
+real gumbel_lccdf(real, vector, real)
+real gumbel_lccdf(real, vector, vector)
+real gumbel_lccdf(real, vector, row_vector)
+real gumbel_lccdf(real, vector, real[])
+real gumbel_lccdf(real, row_vector, real)
+real gumbel_lccdf(real, row_vector, vector)
+real gumbel_lccdf(real, row_vector, row_vector)
+real gumbel_lccdf(real, row_vector, real[])
+real gumbel_lccdf(real, real[], vector)
+real gumbel_lccdf(real, real[], row_vector)
+real gumbel_lccdf(vector, real, real)
+real gumbel_lccdf(vector, real, vector)
+real gumbel_lccdf(vector, real, row_vector)
+real gumbel_lccdf(vector, real, real[])
+real gumbel_lccdf(vector, vector, real)
+real gumbel_lccdf(vector, vector, vector)
+real gumbel_lccdf(vector, vector, row_vector)
+real gumbel_lccdf(vector, vector, real[])
+real gumbel_lccdf(vector, row_vector, real)
+real gumbel_lccdf(vector, row_vector, vector)
+real gumbel_lccdf(vector, row_vector, row_vector)
+real gumbel_lccdf(vector, row_vector, real[])
+real gumbel_lccdf(vector, real[], real)
+real gumbel_lccdf(vector, real[], vector)
+real gumbel_lccdf(vector, real[], row_vector)
+real gumbel_lccdf(vector, real[], real[])
+real gumbel_lccdf(row_vector, real, real)
+real gumbel_lccdf(row_vector, real, vector)
+real gumbel_lccdf(row_vector, real, row_vector)
+real gumbel_lccdf(row_vector, real, real[])
+real gumbel_lccdf(row_vector, vector, real)
+real gumbel_lccdf(row_vector, vector, vector)
+real gumbel_lccdf(row_vector, vector, row_vector)
+real gumbel_lccdf(row_vector, vector, real[])
+real gumbel_lccdf(row_vector, row_vector, real)
+real gumbel_lccdf(row_vector, row_vector, vector)
+real gumbel_lccdf(row_vector, row_vector, row_vector)
+real gumbel_lccdf(row_vector, row_vector, real[])
+real gumbel_lccdf(row_vector, real[], real)
+real gumbel_lccdf(row_vector, real[], vector)
+real gumbel_lccdf(row_vector, real[], row_vector)
+real gumbel_lccdf(row_vector, real[], real[])
+real gumbel_lccdf(real[], real, vector)
+real gumbel_lccdf(real[], real, row_vector)
+real gumbel_lccdf(real[], vector, real)
+real gumbel_lccdf(real[], vector, vector)
+real gumbel_lccdf(real[], vector, row_vector)
+real gumbel_lccdf(real[], vector, real[])
+real gumbel_lccdf(real[], row_vector, real)
+real gumbel_lccdf(real[], row_vector, vector)
+real gumbel_lccdf(real[], row_vector, row_vector)
+real gumbel_lccdf(real[], row_vector, real[])
+real gumbel_lccdf(real[], real[], vector)
+real gumbel_lccdf(real[], real[], row_vector)
+real gumbel_lcdf(real, real, vector)
+real gumbel_lcdf(real, real, row_vector)
+real gumbel_lcdf(real, vector, real)
+real gumbel_lcdf(real, vector, vector)
+real gumbel_lcdf(real, vector, row_vector)
+real gumbel_lcdf(real, vector, real[])
+real gumbel_lcdf(real, row_vector, real)
+real gumbel_lcdf(real, row_vector, vector)
+real gumbel_lcdf(real, row_vector, row_vector)
+real gumbel_lcdf(real, row_vector, real[])
+real gumbel_lcdf(real, real[], vector)
+real gumbel_lcdf(real, real[], row_vector)
+real gumbel_lcdf(vector, real, real)
+real gumbel_lcdf(vector, real, vector)
+real gumbel_lcdf(vector, real, row_vector)
+real gumbel_lcdf(vector, real, real[])
+real gumbel_lcdf(vector, vector, real)
+real gumbel_lcdf(vector, vector, vector)
+real gumbel_lcdf(vector, vector, row_vector)
+real gumbel_lcdf(vector, vector, real[])
+real gumbel_lcdf(vector, row_vector, real)
+real gumbel_lcdf(vector, row_vector, vector)
+real gumbel_lcdf(vector, row_vector, row_vector)
+real gumbel_lcdf(vector, row_vector, real[])
+real gumbel_lcdf(vector, real[], real)
+real gumbel_lcdf(vector, real[], vector)
+real gumbel_lcdf(vector, real[], row_vector)
+real gumbel_lcdf(vector, real[], real[])
+real gumbel_lcdf(row_vector, real, real)
+real gumbel_lcdf(row_vector, real, vector)
+real gumbel_lcdf(row_vector, real, row_vector)
+real gumbel_lcdf(row_vector, real, real[])
+real gumbel_lcdf(row_vector, vector, real)
+real gumbel_lcdf(row_vector, vector, vector)
+real gumbel_lcdf(row_vector, vector, row_vector)
+real gumbel_lcdf(row_vector, vector, real[])
+real gumbel_lcdf(row_vector, row_vector, real)
+real gumbel_lcdf(row_vector, row_vector, vector)
+real gumbel_lcdf(row_vector, row_vector, row_vector)
+real gumbel_lcdf(row_vector, row_vector, real[])
+real gumbel_lcdf(row_vector, real[], real)
+real gumbel_lcdf(row_vector, real[], vector)
+real gumbel_lcdf(row_vector, real[], row_vector)
+real gumbel_lcdf(row_vector, real[], real[])
+real gumbel_lcdf(real[], real, vector)
+real gumbel_lcdf(real[], real, row_vector)
+real gumbel_lcdf(real[], vector, real)
+real gumbel_lcdf(real[], vector, vector)
+real gumbel_lcdf(real[], vector, row_vector)
+real gumbel_lcdf(real[], vector, real[])
+real gumbel_lcdf(real[], row_vector, real)
+real gumbel_lcdf(real[], row_vector, vector)
+real gumbel_lcdf(real[], row_vector, row_vector)
+real gumbel_lcdf(real[], row_vector, real[])
+real gumbel_lcdf(real[], real[], vector)
+real gumbel_lcdf(real[], real[], row_vector)
+real gumbel_log(real, real, vector)
+real gumbel_log(real, real, row_vector)
+real gumbel_log(real, vector, real)
+real gumbel_log(real, vector, vector)
+real gumbel_log(real, vector, row_vector)
+real gumbel_log(real, vector, real[])
+real gumbel_log(real, row_vector, real)
+real gumbel_log(real, row_vector, vector)
+real gumbel_log(real, row_vector, row_vector)
+real gumbel_log(real, row_vector, real[])
+real gumbel_log(real, real[], vector)
+real gumbel_log(real, real[], row_vector)
+real gumbel_log(vector, real, real)
+real gumbel_log(vector, real, vector)
+real gumbel_log(vector, real, row_vector)
+real gumbel_log(vector, real, real[])
+real gumbel_log(vector, vector, real)
+real gumbel_log(vector, vector, vector)
+real gumbel_log(vector, vector, row_vector)
+real gumbel_log(vector, vector, real[])
+real gumbel_log(vector, row_vector, real)
+real gumbel_log(vector, row_vector, vector)
+real gumbel_log(vector, row_vector, row_vector)
+real gumbel_log(vector, row_vector, real[])
+real gumbel_log(vector, real[], real)
+real gumbel_log(vector, real[], vector)
+real gumbel_log(vector, real[], row_vector)
+real gumbel_log(vector, real[], real[])
+real gumbel_log(row_vector, real, real)
+real gumbel_log(row_vector, real, vector)
+real gumbel_log(row_vector, real, row_vector)
+real gumbel_log(row_vector, real, real[])
+real gumbel_log(row_vector, vector, real)
+real gumbel_log(row_vector, vector, vector)
+real gumbel_log(row_vector, vector, row_vector)
+real gumbel_log(row_vector, vector, real[])
+real gumbel_log(row_vector, row_vector, real)
+real gumbel_log(row_vector, row_vector, vector)
+real gumbel_log(row_vector, row_vector, row_vector)
+real gumbel_log(row_vector, row_vector, real[])
+real gumbel_log(row_vector, real[], real)
+real gumbel_log(row_vector, real[], vector)
+real gumbel_log(row_vector, real[], row_vector)
+real gumbel_log(row_vector, real[], real[])
+real gumbel_log(real[], real, vector)
+real gumbel_log(real[], real, row_vector)
+real gumbel_log(real[], vector, real)
+real gumbel_log(real[], vector, vector)
+real gumbel_log(real[], vector, row_vector)
+real gumbel_log(real[], vector, real[])
+real gumbel_log(real[], row_vector, real)
+real gumbel_log(real[], row_vector, vector)
+real gumbel_log(real[], row_vector, row_vector)
+real gumbel_log(real[], row_vector, real[])
+real gumbel_log(real[], real[], vector)
+real gumbel_log(real[], real[], row_vector)
+real gumbel_lpdf(real, real, vector)
+real gumbel_lpdf(real, real, row_vector)
+real gumbel_lpdf(real, vector, real)
+real gumbel_lpdf(real, vector, vector)
+real gumbel_lpdf(real, vector, row_vector)
+real gumbel_lpdf(real, vector, real[])
+real gumbel_lpdf(real, row_vector, real)
+real gumbel_lpdf(real, row_vector, vector)
+real gumbel_lpdf(real, row_vector, row_vector)
+real gumbel_lpdf(real, row_vector, real[])
+real gumbel_lpdf(real, real[], vector)
+real gumbel_lpdf(real, real[], row_vector)
+real gumbel_lpdf(vector, real, real)
+real gumbel_lpdf(vector, real, vector)
+real gumbel_lpdf(vector, real, row_vector)
+real gumbel_lpdf(vector, real, real[])
+real gumbel_lpdf(vector, vector, real)
+real gumbel_lpdf(vector, vector, vector)
+real gumbel_lpdf(vector, vector, row_vector)
+real gumbel_lpdf(vector, vector, real[])
+real gumbel_lpdf(vector, row_vector, real)
+real gumbel_lpdf(vector, row_vector, vector)
+real gumbel_lpdf(vector, row_vector, row_vector)
+real gumbel_lpdf(vector, row_vector, real[])
+real gumbel_lpdf(vector, real[], real)
+real gumbel_lpdf(vector, real[], vector)
+real gumbel_lpdf(vector, real[], row_vector)
+real gumbel_lpdf(vector, real[], real[])
+real gumbel_lpdf(row_vector, real, real)
+real gumbel_lpdf(row_vector, real, vector)
+real gumbel_lpdf(row_vector, real, row_vector)
+real gumbel_lpdf(row_vector, real, real[])
+real gumbel_lpdf(row_vector, vector, real)
+real gumbel_lpdf(row_vector, vector, vector)
+real gumbel_lpdf(row_vector, vector, row_vector)
+real gumbel_lpdf(row_vector, vector, real[])
+real gumbel_lpdf(row_vector, row_vector, real)
+real gumbel_lpdf(row_vector, row_vector, vector)
+real gumbel_lpdf(row_vector, row_vector, row_vector)
+real gumbel_lpdf(row_vector, row_vector, real[])
+real gumbel_lpdf(row_vector, real[], real)
+real gumbel_lpdf(row_vector, real[], vector)
+real gumbel_lpdf(row_vector, real[], row_vector)
+real gumbel_lpdf(row_vector, real[], real[])
+real gumbel_lpdf(real[], real, vector)
+real gumbel_lpdf(real[], real, row_vector)
+real gumbel_lpdf(real[], vector, real)
+real gumbel_lpdf(real[], vector, vector)
+real gumbel_lpdf(real[], vector, row_vector)
+real gumbel_lpdf(real[], vector, real[])
+real gumbel_lpdf(real[], row_vector, real)
+real gumbel_lpdf(real[], row_vector, vector)
+real gumbel_lpdf(real[], row_vector, row_vector)
+real gumbel_lpdf(real[], row_vector, real[])
+real gumbel_lpdf(real[], real[], vector)
+real gumbel_lpdf(real[], real[], row_vector)
+real[] gumbel_rng(int, vector)
+real[] gumbel_rng(int, row_vector)
+real[] gumbel_rng(real, vector)
+real[] gumbel_rng(real, row_vector)
+real[] gumbel_rng(vector, int)
+real[] gumbel_rng(vector, real)
+real[] gumbel_rng(vector, vector)
+real[] gumbel_rng(vector, row_vector)
+real[] gumbel_rng(vector, int[])
+real[] gumbel_rng(vector, real[])
+real[] gumbel_rng(row_vector, int)
+real[] gumbel_rng(row_vector, real)
+real[] gumbel_rng(row_vector, vector)
+real[] gumbel_rng(row_vector, row_vector)
+real[] gumbel_rng(row_vector, int[])
+real[] gumbel_rng(row_vector, real[])
+real[] gumbel_rng(int[], vector)
+real[] gumbel_rng(int[], row_vector)
+real[] gumbel_rng(real[], vector)
+real[] gumbel_rng(real[], row_vector)
+matrix hmm_hidden_state_prob(matrix, matrix, vector)
+int[] hmm_latent_rng(matrix, matrix, vector)
+real hmm_marginal(matrix, matrix, vector)
+int if_else(int, int, int)
+real if_else(int, real, real)
+vector if_else(int, vector, vector)
+row_vector if_else(int, row_vector, row_vector)
+matrix if_else(int, matrix, matrix)
+int[] if_else(int, int[], int[])
+real[] if_else(int, real[], real[])
+vector[] if_else(int, vector[], vector[])
+row_vector[] if_else(int, row_vector[], row_vector[])
+matrix[] if_else(int, matrix[], matrix[])
+int[,] if_else(int, int[,], int[,])
+real[,] if_else(int, real[,], real[,])
+vector[,] if_else(int, vector[,], vector[,])
+row_vector[,] if_else(int, row_vector[,], row_vector[,])
+matrix[,] if_else(int, matrix[,], matrix[,])
+int[,,] if_else(int, int[,,], int[,,])
+real[,,] if_else(int, real[,,], real[,,])
+vector[,,] if_else(int, vector[,,], vector[,,])
+row_vector[,,] if_else(int, row_vector[,,], row_vector[,,])
+matrix[,,] if_else(int, matrix[,,], matrix[,,])
+int[,,,] if_else(int, int[,,,], int[,,,])
+real[,,,] if_else(int, real[,,,], real[,,,])
+vector[,,,] if_else(int, vector[,,,], vector[,,,])
+row_vector[,,,] if_else(int, row_vector[,,,], row_vector[,,,])
+matrix[,,,] if_else(int, matrix[,,,], matrix[,,,])
+int[,,,,] if_else(int, int[,,,,], int[,,,,])
+real[,,,,] if_else(int, real[,,,,], real[,,,,])
+vector[,,,,] if_else(int, vector[,,,,], vector[,,,,])
+row_vector[,,,,] if_else(int, row_vector[,,,,], row_vector[,,,,])
+matrix[,,,,] if_else(int, matrix[,,,,], matrix[,,,,])
+int[,,,,,] if_else(int, int[,,,,,], int[,,,,,])
+real[,,,,,] if_else(int, real[,,,,,], real[,,,,,])
+vector[,,,,,] if_else(int, vector[,,,,,], vector[,,,,,])
+row_vector[,,,,,] if_else(int, row_vector[,,,,,], row_vector[,,,,,])
+matrix[,,,,,] if_else(int, matrix[,,,,,], matrix[,,,,,])
+int[,,,,,,] if_else(int, int[,,,,,,], int[,,,,,,])
+real[,,,,,,] if_else(int, real[,,,,,,], real[,,,,,,])
+vector[,,,,,,] if_else(int, vector[,,,,,,], vector[,,,,,,])
+row_vector[,,,,,,] if_else(int, row_vector[,,,,,,], row_vector[,,,,,,])
+matrix[,,,,,,] if_else(int, matrix[,,,,,,], matrix[,,,,,,])
+real inv_chi_square_ccdf_log(real, vector)
+real inv_chi_square_ccdf_log(real, row_vector)
+real inv_chi_square_ccdf_log(vector, real)
+real inv_chi_square_ccdf_log(vector, vector)
+real inv_chi_square_ccdf_log(vector, row_vector)
+real inv_chi_square_ccdf_log(vector, real[])
+real inv_chi_square_ccdf_log(row_vector, real)
+real inv_chi_square_ccdf_log(row_vector, vector)
+real inv_chi_square_ccdf_log(row_vector, row_vector)
+real inv_chi_square_ccdf_log(row_vector, real[])
+real inv_chi_square_ccdf_log(real[], vector)
+real inv_chi_square_ccdf_log(real[], row_vector)
+real inv_chi_square_cdf(real, vector)
+real inv_chi_square_cdf(real, row_vector)
+real inv_chi_square_cdf(vector, real)
+real inv_chi_square_cdf(vector, vector)
+real inv_chi_square_cdf(vector, row_vector)
+real inv_chi_square_cdf(vector, real[])
+real inv_chi_square_cdf(row_vector, real)
+real inv_chi_square_cdf(row_vector, vector)
+real inv_chi_square_cdf(row_vector, row_vector)
+real inv_chi_square_cdf(row_vector, real[])
+real inv_chi_square_cdf(real[], vector)
+real inv_chi_square_cdf(real[], row_vector)
+real inv_chi_square_cdf_log(real, vector)
+real inv_chi_square_cdf_log(real, row_vector)
+real inv_chi_square_cdf_log(vector, real)
+real inv_chi_square_cdf_log(vector, vector)
+real inv_chi_square_cdf_log(vector, row_vector)
+real inv_chi_square_cdf_log(vector, real[])
+real inv_chi_square_cdf_log(row_vector, real)
+real inv_chi_square_cdf_log(row_vector, vector)
+real inv_chi_square_cdf_log(row_vector, row_vector)
+real inv_chi_square_cdf_log(row_vector, real[])
+real inv_chi_square_cdf_log(real[], vector)
+real inv_chi_square_cdf_log(real[], row_vector)
+real inv_chi_square_lccdf(real, vector)
+real inv_chi_square_lccdf(real, row_vector)
+real inv_chi_square_lccdf(vector, real)
+real inv_chi_square_lccdf(vector, vector)
+real inv_chi_square_lccdf(vector, row_vector)
+real inv_chi_square_lccdf(vector, real[])
+real inv_chi_square_lccdf(row_vector, real)
+real inv_chi_square_lccdf(row_vector, vector)
+real inv_chi_square_lccdf(row_vector, row_vector)
+real inv_chi_square_lccdf(row_vector, real[])
+real inv_chi_square_lccdf(real[], vector)
+real inv_chi_square_lccdf(real[], row_vector)
+real inv_chi_square_lcdf(real, vector)
+real inv_chi_square_lcdf(real, row_vector)
+real inv_chi_square_lcdf(vector, real)
+real inv_chi_square_lcdf(vector, vector)
+real inv_chi_square_lcdf(vector, row_vector)
+real inv_chi_square_lcdf(vector, real[])
+real inv_chi_square_lcdf(row_vector, real)
+real inv_chi_square_lcdf(row_vector, vector)
+real inv_chi_square_lcdf(row_vector, row_vector)
+real inv_chi_square_lcdf(row_vector, real[])
+real inv_chi_square_lcdf(real[], vector)
+real inv_chi_square_lcdf(real[], row_vector)
+real inv_chi_square_log(real, vector)
+real inv_chi_square_log(real, row_vector)
+real inv_chi_square_log(vector, real)
+real inv_chi_square_log(vector, vector)
+real inv_chi_square_log(vector, row_vector)
+real inv_chi_square_log(vector, real[])
+real inv_chi_square_log(row_vector, real)
+real inv_chi_square_log(row_vector, vector)
+real inv_chi_square_log(row_vector, row_vector)
+real inv_chi_square_log(row_vector, real[])
+real inv_chi_square_log(real[], vector)
+real inv_chi_square_log(real[], row_vector)
+real inv_chi_square_lpdf(real, vector)
+real inv_chi_square_lpdf(real, row_vector)
+real inv_chi_square_lpdf(vector, real)
+real inv_chi_square_lpdf(vector, vector)
+real inv_chi_square_lpdf(vector, row_vector)
+real inv_chi_square_lpdf(vector, real[])
+real inv_chi_square_lpdf(row_vector, real)
+real inv_chi_square_lpdf(row_vector, vector)
+real inv_chi_square_lpdf(row_vector, row_vector)
+real inv_chi_square_lpdf(row_vector, real[])
+real inv_chi_square_lpdf(real[], vector)
+real inv_chi_square_lpdf(real[], row_vector)
+real[] inv_chi_square_rng(vector)
+real[] inv_chi_square_rng(row_vector)
+real inv_gamma_ccdf_log(real, real, vector)
+real inv_gamma_ccdf_log(real, real, row_vector)
+real inv_gamma_ccdf_log(real, vector, real)
+real inv_gamma_ccdf_log(real, vector, vector)
+real inv_gamma_ccdf_log(real, vector, row_vector)
+real inv_gamma_ccdf_log(real, vector, real[])
+real inv_gamma_ccdf_log(real, row_vector, real)
+real inv_gamma_ccdf_log(real, row_vector, vector)
+real inv_gamma_ccdf_log(real, row_vector, row_vector)
+real inv_gamma_ccdf_log(real, row_vector, real[])
+real inv_gamma_ccdf_log(real, real[], vector)
+real inv_gamma_ccdf_log(real, real[], row_vector)
+real inv_gamma_ccdf_log(vector, real, real)
+real inv_gamma_ccdf_log(vector, real, vector)
+real inv_gamma_ccdf_log(vector, real, row_vector)
+real inv_gamma_ccdf_log(vector, real, real[])
+real inv_gamma_ccdf_log(vector, vector, real)
+real inv_gamma_ccdf_log(vector, vector, vector)
+real inv_gamma_ccdf_log(vector, vector, row_vector)
+real inv_gamma_ccdf_log(vector, vector, real[])
+real inv_gamma_ccdf_log(vector, row_vector, real)
+real inv_gamma_ccdf_log(vector, row_vector, vector)
+real inv_gamma_ccdf_log(vector, row_vector, row_vector)
+real inv_gamma_ccdf_log(vector, row_vector, real[])
+real inv_gamma_ccdf_log(vector, real[], real)
+real inv_gamma_ccdf_log(vector, real[], vector)
+real inv_gamma_ccdf_log(vector, real[], row_vector)
+real inv_gamma_ccdf_log(vector, real[], real[])
+real inv_gamma_ccdf_log(row_vector, real, real)
+real inv_gamma_ccdf_log(row_vector, real, vector)
+real inv_gamma_ccdf_log(row_vector, real, row_vector)
+real inv_gamma_ccdf_log(row_vector, real, real[])
+real inv_gamma_ccdf_log(row_vector, vector, real)
+real inv_gamma_ccdf_log(row_vector, vector, vector)
+real inv_gamma_ccdf_log(row_vector, vector, row_vector)
+real inv_gamma_ccdf_log(row_vector, vector, real[])
+real inv_gamma_ccdf_log(row_vector, row_vector, real)
+real inv_gamma_ccdf_log(row_vector, row_vector, vector)
+real inv_gamma_ccdf_log(row_vector, row_vector, row_vector)
+real inv_gamma_ccdf_log(row_vector, row_vector, real[])
+real inv_gamma_ccdf_log(row_vector, real[], real)
+real inv_gamma_ccdf_log(row_vector, real[], vector)
+real inv_gamma_ccdf_log(row_vector, real[], row_vector)
+real inv_gamma_ccdf_log(row_vector, real[], real[])
+real inv_gamma_ccdf_log(real[], real, vector)
+real inv_gamma_ccdf_log(real[], real, row_vector)
+real inv_gamma_ccdf_log(real[], vector, real)
+real inv_gamma_ccdf_log(real[], vector, vector)
+real inv_gamma_ccdf_log(real[], vector, row_vector)
+real inv_gamma_ccdf_log(real[], vector, real[])
+real inv_gamma_ccdf_log(real[], row_vector, real)
+real inv_gamma_ccdf_log(real[], row_vector, vector)
+real inv_gamma_ccdf_log(real[], row_vector, row_vector)
+real inv_gamma_ccdf_log(real[], row_vector, real[])
+real inv_gamma_ccdf_log(real[], real[], vector)
+real inv_gamma_ccdf_log(real[], real[], row_vector)
+real inv_gamma_cdf(real, real, vector)
+real inv_gamma_cdf(real, real, row_vector)
+real inv_gamma_cdf(real, vector, real)
+real inv_gamma_cdf(real, vector, vector)
+real inv_gamma_cdf(real, vector, row_vector)
+real inv_gamma_cdf(real, vector, real[])
+real inv_gamma_cdf(real, row_vector, real)
+real inv_gamma_cdf(real, row_vector, vector)
+real inv_gamma_cdf(real, row_vector, row_vector)
+real inv_gamma_cdf(real, row_vector, real[])
+real inv_gamma_cdf(real, real[], vector)
+real inv_gamma_cdf(real, real[], row_vector)
+real inv_gamma_cdf(vector, real, real)
+real inv_gamma_cdf(vector, real, vector)
+real inv_gamma_cdf(vector, real, row_vector)
+real inv_gamma_cdf(vector, real, real[])
+real inv_gamma_cdf(vector, vector, real)
+real inv_gamma_cdf(vector, vector, vector)
+real inv_gamma_cdf(vector, vector, row_vector)
+real inv_gamma_cdf(vector, vector, real[])
+real inv_gamma_cdf(vector, row_vector, real)
+real inv_gamma_cdf(vector, row_vector, vector)
+real inv_gamma_cdf(vector, row_vector, row_vector)
+real inv_gamma_cdf(vector, row_vector, real[])
+real inv_gamma_cdf(vector, real[], real)
+real inv_gamma_cdf(vector, real[], vector)
+real inv_gamma_cdf(vector, real[], row_vector)
+real inv_gamma_cdf(vector, real[], real[])
+real inv_gamma_cdf(row_vector, real, real)
+real inv_gamma_cdf(row_vector, real, vector)
+real inv_gamma_cdf(row_vector, real, row_vector)
+real inv_gamma_cdf(row_vector, real, real[])
+real inv_gamma_cdf(row_vector, vector, real)
+real inv_gamma_cdf(row_vector, vector, vector)
+real inv_gamma_cdf(row_vector, vector, row_vector)
+real inv_gamma_cdf(row_vector, vector, real[])
+real inv_gamma_cdf(row_vector, row_vector, real)
+real inv_gamma_cdf(row_vector, row_vector, vector)
+real inv_gamma_cdf(row_vector, row_vector, row_vector)
+real inv_gamma_cdf(row_vector, row_vector, real[])
+real inv_gamma_cdf(row_vector, real[], real)
+real inv_gamma_cdf(row_vector, real[], vector)
+real inv_gamma_cdf(row_vector, real[], row_vector)
+real inv_gamma_cdf(row_vector, real[], real[])
+real inv_gamma_cdf(real[], real, vector)
+real inv_gamma_cdf(real[], real, row_vector)
+real inv_gamma_cdf(real[], vector, real)
+real inv_gamma_cdf(real[], vector, vector)
+real inv_gamma_cdf(real[], vector, row_vector)
+real inv_gamma_cdf(real[], vector, real[])
+real inv_gamma_cdf(real[], row_vector, real)
+real inv_gamma_cdf(real[], row_vector, vector)
+real inv_gamma_cdf(real[], row_vector, row_vector)
+real inv_gamma_cdf(real[], row_vector, real[])
+real inv_gamma_cdf(real[], real[], vector)
+real inv_gamma_cdf(real[], real[], row_vector)
+real inv_gamma_cdf_log(real, real, vector)
+real inv_gamma_cdf_log(real, real, row_vector)
+real inv_gamma_cdf_log(real, vector, real)
+real inv_gamma_cdf_log(real, vector, vector)
+real inv_gamma_cdf_log(real, vector, row_vector)
+real inv_gamma_cdf_log(real, vector, real[])
+real inv_gamma_cdf_log(real, row_vector, real)
+real inv_gamma_cdf_log(real, row_vector, vector)
+real inv_gamma_cdf_log(real, row_vector, row_vector)
+real inv_gamma_cdf_log(real, row_vector, real[])
+real inv_gamma_cdf_log(real, real[], vector)
+real inv_gamma_cdf_log(real, real[], row_vector)
+real inv_gamma_cdf_log(vector, real, real)
+real inv_gamma_cdf_log(vector, real, vector)
+real inv_gamma_cdf_log(vector, real, row_vector)
+real inv_gamma_cdf_log(vector, real, real[])
+real inv_gamma_cdf_log(vector, vector, real)
+real inv_gamma_cdf_log(vector, vector, vector)
+real inv_gamma_cdf_log(vector, vector, row_vector)
+real inv_gamma_cdf_log(vector, vector, real[])
+real inv_gamma_cdf_log(vector, row_vector, real)
+real inv_gamma_cdf_log(vector, row_vector, vector)
+real inv_gamma_cdf_log(vector, row_vector, row_vector)
+real inv_gamma_cdf_log(vector, row_vector, real[])
+real inv_gamma_cdf_log(vector, real[], real)
+real inv_gamma_cdf_log(vector, real[], vector)
+real inv_gamma_cdf_log(vector, real[], row_vector)
+real inv_gamma_cdf_log(vector, real[], real[])
+real inv_gamma_cdf_log(row_vector, real, real)
+real inv_gamma_cdf_log(row_vector, real, vector)
+real inv_gamma_cdf_log(row_vector, real, row_vector)
+real inv_gamma_cdf_log(row_vector, real, real[])
+real inv_gamma_cdf_log(row_vector, vector, real)
+real inv_gamma_cdf_log(row_vector, vector, vector)
+real inv_gamma_cdf_log(row_vector, vector, row_vector)
+real inv_gamma_cdf_log(row_vector, vector, real[])
+real inv_gamma_cdf_log(row_vector, row_vector, real)
+real inv_gamma_cdf_log(row_vector, row_vector, vector)
+real inv_gamma_cdf_log(row_vector, row_vector, row_vector)
+real inv_gamma_cdf_log(row_vector, row_vector, real[])
+real inv_gamma_cdf_log(row_vector, real[], real)
+real inv_gamma_cdf_log(row_vector, real[], vector)
+real inv_gamma_cdf_log(row_vector, real[], row_vector)
+real inv_gamma_cdf_log(row_vector, real[], real[])
+real inv_gamma_cdf_log(real[], real, vector)
+real inv_gamma_cdf_log(real[], real, row_vector)
+real inv_gamma_cdf_log(real[], vector, real)
+real inv_gamma_cdf_log(real[], vector, vector)
+real inv_gamma_cdf_log(real[], vector, row_vector)
+real inv_gamma_cdf_log(real[], vector, real[])
+real inv_gamma_cdf_log(real[], row_vector, real)
+real inv_gamma_cdf_log(real[], row_vector, vector)
+real inv_gamma_cdf_log(real[], row_vector, row_vector)
+real inv_gamma_cdf_log(real[], row_vector, real[])
+real inv_gamma_cdf_log(real[], real[], vector)
+real inv_gamma_cdf_log(real[], real[], row_vector)
+real inv_gamma_lccdf(real, real, vector)
+real inv_gamma_lccdf(real, real, row_vector)
+real inv_gamma_lccdf(real, vector, real)
+real inv_gamma_lccdf(real, vector, vector)
+real inv_gamma_lccdf(real, vector, row_vector)
+real inv_gamma_lccdf(real, vector, real[])
+real inv_gamma_lccdf(real, row_vector, real)
+real inv_gamma_lccdf(real, row_vector, vector)
+real inv_gamma_lccdf(real, row_vector, row_vector)
+real inv_gamma_lccdf(real, row_vector, real[])
+real inv_gamma_lccdf(real, real[], vector)
+real inv_gamma_lccdf(real, real[], row_vector)
+real inv_gamma_lccdf(vector, real, real)
+real inv_gamma_lccdf(vector, real, vector)
+real inv_gamma_lccdf(vector, real, row_vector)
+real inv_gamma_lccdf(vector, real, real[])
+real inv_gamma_lccdf(vector, vector, real)
+real inv_gamma_lccdf(vector, vector, vector)
+real inv_gamma_lccdf(vector, vector, row_vector)
+real inv_gamma_lccdf(vector, vector, real[])
+real inv_gamma_lccdf(vector, row_vector, real)
+real inv_gamma_lccdf(vector, row_vector, vector)
+real inv_gamma_lccdf(vector, row_vector, row_vector)
+real inv_gamma_lccdf(vector, row_vector, real[])
+real inv_gamma_lccdf(vector, real[], real)
+real inv_gamma_lccdf(vector, real[], vector)
+real inv_gamma_lccdf(vector, real[], row_vector)
+real inv_gamma_lccdf(vector, real[], real[])
+real inv_gamma_lccdf(row_vector, real, real)
+real inv_gamma_lccdf(row_vector, real, vector)
+real inv_gamma_lccdf(row_vector, real, row_vector)
+real inv_gamma_lccdf(row_vector, real, real[])
+real inv_gamma_lccdf(row_vector, vector, real)
+real inv_gamma_lccdf(row_vector, vector, vector)
+real inv_gamma_lccdf(row_vector, vector, row_vector)
+real inv_gamma_lccdf(row_vector, vector, real[])
+real inv_gamma_lccdf(row_vector, row_vector, real)
+real inv_gamma_lccdf(row_vector, row_vector, vector)
+real inv_gamma_lccdf(row_vector, row_vector, row_vector)
+real inv_gamma_lccdf(row_vector, row_vector, real[])
+real inv_gamma_lccdf(row_vector, real[], real)
+real inv_gamma_lccdf(row_vector, real[], vector)
+real inv_gamma_lccdf(row_vector, real[], row_vector)
+real inv_gamma_lccdf(row_vector, real[], real[])
+real inv_gamma_lccdf(real[], real, vector)
+real inv_gamma_lccdf(real[], real, row_vector)
+real inv_gamma_lccdf(real[], vector, real)
+real inv_gamma_lccdf(real[], vector, vector)
+real inv_gamma_lccdf(real[], vector, row_vector)
+real inv_gamma_lccdf(real[], vector, real[])
+real inv_gamma_lccdf(real[], row_vector, real)
+real inv_gamma_lccdf(real[], row_vector, vector)
+real inv_gamma_lccdf(real[], row_vector, row_vector)
+real inv_gamma_lccdf(real[], row_vector, real[])
+real inv_gamma_lccdf(real[], real[], vector)
+real inv_gamma_lccdf(real[], real[], row_vector)
+real inv_gamma_lcdf(real, real, vector)
+real inv_gamma_lcdf(real, real, row_vector)
+real inv_gamma_lcdf(real, vector, real)
+real inv_gamma_lcdf(real, vector, vector)
+real inv_gamma_lcdf(real, vector, row_vector)
+real inv_gamma_lcdf(real, vector, real[])
+real inv_gamma_lcdf(real, row_vector, real)
+real inv_gamma_lcdf(real, row_vector, vector)
+real inv_gamma_lcdf(real, row_vector, row_vector)
+real inv_gamma_lcdf(real, row_vector, real[])
+real inv_gamma_lcdf(real, real[], vector)
+real inv_gamma_lcdf(real, real[], row_vector)
+real inv_gamma_lcdf(vector, real, real)
+real inv_gamma_lcdf(vector, real, vector)
+real inv_gamma_lcdf(vector, real, row_vector)
+real inv_gamma_lcdf(vector, real, real[])
+real inv_gamma_lcdf(vector, vector, real)
+real inv_gamma_lcdf(vector, vector, vector)
+real inv_gamma_lcdf(vector, vector, row_vector)
+real inv_gamma_lcdf(vector, vector, real[])
+real inv_gamma_lcdf(vector, row_vector, real)
+real inv_gamma_lcdf(vector, row_vector, vector)
+real inv_gamma_lcdf(vector, row_vector, row_vector)
+real inv_gamma_lcdf(vector, row_vector, real[])
+real inv_gamma_lcdf(vector, real[], real)
+real inv_gamma_lcdf(vector, real[], vector)
+real inv_gamma_lcdf(vector, real[], row_vector)
+real inv_gamma_lcdf(vector, real[], real[])
+real inv_gamma_lcdf(row_vector, real, real)
+real inv_gamma_lcdf(row_vector, real, vector)
+real inv_gamma_lcdf(row_vector, real, row_vector)
+real inv_gamma_lcdf(row_vector, real, real[])
+real inv_gamma_lcdf(row_vector, vector, real)
+real inv_gamma_lcdf(row_vector, vector, vector)
+real inv_gamma_lcdf(row_vector, vector, row_vector)
+real inv_gamma_lcdf(row_vector, vector, real[])
+real inv_gamma_lcdf(row_vector, row_vector, real)
+real inv_gamma_lcdf(row_vector, row_vector, vector)
+real inv_gamma_lcdf(row_vector, row_vector, row_vector)
+real inv_gamma_lcdf(row_vector, row_vector, real[])
+real inv_gamma_lcdf(row_vector, real[], real)
+real inv_gamma_lcdf(row_vector, real[], vector)
+real inv_gamma_lcdf(row_vector, real[], row_vector)
+real inv_gamma_lcdf(row_vector, real[], real[])
+real inv_gamma_lcdf(real[], real, vector)
+real inv_gamma_lcdf(real[], real, row_vector)
+real inv_gamma_lcdf(real[], vector, real)
+real inv_gamma_lcdf(real[], vector, vector)
+real inv_gamma_lcdf(real[], vector, row_vector)
+real inv_gamma_lcdf(real[], vector, real[])
+real inv_gamma_lcdf(real[], row_vector, real)
+real inv_gamma_lcdf(real[], row_vector, vector)
+real inv_gamma_lcdf(real[], row_vector, row_vector)
+real inv_gamma_lcdf(real[], row_vector, real[])
+real inv_gamma_lcdf(real[], real[], vector)
+real inv_gamma_lcdf(real[], real[], row_vector)
+real inv_gamma_log(real, real, vector)
+real inv_gamma_log(real, real, row_vector)
+real inv_gamma_log(real, vector, real)
+real inv_gamma_log(real, vector, vector)
+real inv_gamma_log(real, vector, row_vector)
+real inv_gamma_log(real, vector, real[])
+real inv_gamma_log(real, row_vector, real)
+real inv_gamma_log(real, row_vector, vector)
+real inv_gamma_log(real, row_vector, row_vector)
+real inv_gamma_log(real, row_vector, real[])
+real inv_gamma_log(real, real[], vector)
+real inv_gamma_log(real, real[], row_vector)
+real inv_gamma_log(vector, real, real)
+real inv_gamma_log(vector, real, vector)
+real inv_gamma_log(vector, real, row_vector)
+real inv_gamma_log(vector, real, real[])
+real inv_gamma_log(vector, vector, real)
+real inv_gamma_log(vector, vector, vector)
+real inv_gamma_log(vector, vector, row_vector)
+real inv_gamma_log(vector, vector, real[])
+real inv_gamma_log(vector, row_vector, real)
+real inv_gamma_log(vector, row_vector, vector)
+real inv_gamma_log(vector, row_vector, row_vector)
+real inv_gamma_log(vector, row_vector, real[])
+real inv_gamma_log(vector, real[], real)
+real inv_gamma_log(vector, real[], vector)
+real inv_gamma_log(vector, real[], row_vector)
+real inv_gamma_log(vector, real[], real[])
+real inv_gamma_log(row_vector, real, real)
+real inv_gamma_log(row_vector, real, vector)
+real inv_gamma_log(row_vector, real, row_vector)
+real inv_gamma_log(row_vector, real, real[])
+real inv_gamma_log(row_vector, vector, real)
+real inv_gamma_log(row_vector, vector, vector)
+real inv_gamma_log(row_vector, vector, row_vector)
+real inv_gamma_log(row_vector, vector, real[])
+real inv_gamma_log(row_vector, row_vector, real)
+real inv_gamma_log(row_vector, row_vector, vector)
+real inv_gamma_log(row_vector, row_vector, row_vector)
+real inv_gamma_log(row_vector, row_vector, real[])
+real inv_gamma_log(row_vector, real[], real)
+real inv_gamma_log(row_vector, real[], vector)
+real inv_gamma_log(row_vector, real[], row_vector)
+real inv_gamma_log(row_vector, real[], real[])
+real inv_gamma_log(real[], real, vector)
+real inv_gamma_log(real[], real, row_vector)
+real inv_gamma_log(real[], vector, real)
+real inv_gamma_log(real[], vector, vector)
+real inv_gamma_log(real[], vector, row_vector)
+real inv_gamma_log(real[], vector, real[])
+real inv_gamma_log(real[], row_vector, real)
+real inv_gamma_log(real[], row_vector, vector)
+real inv_gamma_log(real[], row_vector, row_vector)
+real inv_gamma_log(real[], row_vector, real[])
+real inv_gamma_log(real[], real[], vector)
+real inv_gamma_log(real[], real[], row_vector)
+real inv_gamma_lpdf(real, real, vector)
+real inv_gamma_lpdf(real, real, row_vector)
+real inv_gamma_lpdf(real, vector, real)
+real inv_gamma_lpdf(real, vector, vector)
+real inv_gamma_lpdf(real, vector, row_vector)
+real inv_gamma_lpdf(real, vector, real[])
+real inv_gamma_lpdf(real, row_vector, real)
+real inv_gamma_lpdf(real, row_vector, vector)
+real inv_gamma_lpdf(real, row_vector, row_vector)
+real inv_gamma_lpdf(real, row_vector, real[])
+real inv_gamma_lpdf(real, real[], vector)
+real inv_gamma_lpdf(real, real[], row_vector)
+real inv_gamma_lpdf(vector, real, real)
+real inv_gamma_lpdf(vector, real, vector)
+real inv_gamma_lpdf(vector, real, row_vector)
+real inv_gamma_lpdf(vector, real, real[])
+real inv_gamma_lpdf(vector, vector, real)
+real inv_gamma_lpdf(vector, vector, vector)
+real inv_gamma_lpdf(vector, vector, row_vector)
+real inv_gamma_lpdf(vector, vector, real[])
+real inv_gamma_lpdf(vector, row_vector, real)
+real inv_gamma_lpdf(vector, row_vector, vector)
+real inv_gamma_lpdf(vector, row_vector, row_vector)
+real inv_gamma_lpdf(vector, row_vector, real[])
+real inv_gamma_lpdf(vector, real[], real)
+real inv_gamma_lpdf(vector, real[], vector)
+real inv_gamma_lpdf(vector, real[], row_vector)
+real inv_gamma_lpdf(vector, real[], real[])
+real inv_gamma_lpdf(row_vector, real, real)
+real inv_gamma_lpdf(row_vector, real, vector)
+real inv_gamma_lpdf(row_vector, real, row_vector)
+real inv_gamma_lpdf(row_vector, real, real[])
+real inv_gamma_lpdf(row_vector, vector, real)
+real inv_gamma_lpdf(row_vector, vector, vector)
+real inv_gamma_lpdf(row_vector, vector, row_vector)
+real inv_gamma_lpdf(row_vector, vector, real[])
+real inv_gamma_lpdf(row_vector, row_vector, real)
+real inv_gamma_lpdf(row_vector, row_vector, vector)
+real inv_gamma_lpdf(row_vector, row_vector, row_vector)
+real inv_gamma_lpdf(row_vector, row_vector, real[])
+real inv_gamma_lpdf(row_vector, real[], real)
+real inv_gamma_lpdf(row_vector, real[], vector)
+real inv_gamma_lpdf(row_vector, real[], row_vector)
+real inv_gamma_lpdf(row_vector, real[], real[])
+real inv_gamma_lpdf(real[], real, vector)
+real inv_gamma_lpdf(real[], real, row_vector)
+real inv_gamma_lpdf(real[], vector, real)
+real inv_gamma_lpdf(real[], vector, vector)
+real inv_gamma_lpdf(real[], vector, row_vector)
+real inv_gamma_lpdf(real[], vector, real[])
+real inv_gamma_lpdf(real[], row_vector, real)
+real inv_gamma_lpdf(real[], row_vector, vector)
+real inv_gamma_lpdf(real[], row_vector, row_vector)
+real inv_gamma_lpdf(real[], row_vector, real[])
+real inv_gamma_lpdf(real[], real[], vector)
+real inv_gamma_lpdf(real[], real[], row_vector)
+real[] inv_gamma_rng(int, vector)
+real[] inv_gamma_rng(int, row_vector)
+real[] inv_gamma_rng(real, vector)
+real[] inv_gamma_rng(real, row_vector)
+real[] inv_gamma_rng(vector, int)
+real[] inv_gamma_rng(vector, real)
+real[] inv_gamma_rng(vector, vector)
+real[] inv_gamma_rng(vector, row_vector)
+real[] inv_gamma_rng(vector, int[])
+real[] inv_gamma_rng(vector, real[])
+real[] inv_gamma_rng(row_vector, int)
+real[] inv_gamma_rng(row_vector, real)
+real[] inv_gamma_rng(row_vector, vector)
+real[] inv_gamma_rng(row_vector, row_vector)
+real[] inv_gamma_rng(row_vector, int[])
+real[] inv_gamma_rng(row_vector, real[])
+real[] inv_gamma_rng(int[], vector)
+real[] inv_gamma_rng(int[], row_vector)
+real[] inv_gamma_rng(real[], vector)
+real[] inv_gamma_rng(real[], row_vector)
+real inv_wishart_log(matrix, real, matrix)
+real inv_wishart_lpdf(matrix, real, matrix)
+matrix inv_wishart_rng(real, matrix)
+vector lambert_w0(vector)
+row_vector lambert_w0(row_vector)
+matrix lambert_w0(matrix)
+vector[] lambert_w0(vector[])
+row_vector[] lambert_w0(row_vector[])
+matrix[] lambert_w0(matrix[])
+vector[,] lambert_w0(vector[,])
+row_vector[,] lambert_w0(row_vector[,])
+matrix[,] lambert_w0(matrix[,])
+vector[,,] lambert_w0(vector[,,])
+row_vector[,,] lambert_w0(row_vector[,,])
+matrix[,,] lambert_w0(matrix[,,])
+vector[,,,] lambert_w0(vector[,,,])
+row_vector[,,,] lambert_w0(row_vector[,,,])
+matrix[,,,] lambert_w0(matrix[,,,])
+vector[,,,,] lambert_w0(vector[,,,,])
+row_vector[,,,,] lambert_w0(row_vector[,,,,])
+matrix[,,,,] lambert_w0(matrix[,,,,])
+vector[,,,,,] lambert_w0(vector[,,,,,])
+row_vector[,,,,,] lambert_w0(row_vector[,,,,,])
+matrix[,,,,,] lambert_w0(matrix[,,,,,])
+vector[,,,,,,] lambert_w0(vector[,,,,,,])
+row_vector[,,,,,,] lambert_w0(row_vector[,,,,,,])
+matrix[,,,,,,] lambert_w0(matrix[,,,,,,])
+vector lambert_wm1(vector)
+row_vector lambert_wm1(row_vector)
+matrix lambert_wm1(matrix)
+vector[] lambert_wm1(vector[])
+row_vector[] lambert_wm1(row_vector[])
+matrix[] lambert_wm1(matrix[])
+vector[,] lambert_wm1(vector[,])
+row_vector[,] lambert_wm1(row_vector[,])
+matrix[,] lambert_wm1(matrix[,])
+vector[,,] lambert_wm1(vector[,,])
+row_vector[,,] lambert_wm1(row_vector[,,])
+matrix[,,] lambert_wm1(matrix[,,])
+vector[,,,] lambert_wm1(vector[,,,])
+row_vector[,,,] lambert_wm1(row_vector[,,,])
+matrix[,,,] lambert_wm1(matrix[,,,])
+vector[,,,,] lambert_wm1(vector[,,,,])
+row_vector[,,,,] lambert_wm1(row_vector[,,,,])
+matrix[,,,,] lambert_wm1(matrix[,,,,])
+vector[,,,,,] lambert_wm1(vector[,,,,,])
+row_vector[,,,,,] lambert_wm1(row_vector[,,,,,])
+matrix[,,,,,] lambert_wm1(matrix[,,,,,])
+vector[,,,,,,] lambert_wm1(vector[,,,,,,])
+row_vector[,,,,,,] lambert_wm1(row_vector[,,,,,,])
+matrix[,,,,,,] lambert_wm1(matrix[,,,,,,])
+real lkj_corr_cholesky_log(matrix, real)
+real lkj_corr_cholesky_lpdf(matrix, real)
+real lkj_corr_log(matrix, real)
+real lkj_corr_lpdf(matrix, real)
+matrix lkj_corr_rng(int, real)
+real lkj_cov_log(matrix, vector, vector, real)
+real log_determinant(matrix)
+real logistic_ccdf_log(real, real, vector)
+real logistic_ccdf_log(real, real, row_vector)
+real logistic_ccdf_log(real, vector, real)
+real logistic_ccdf_log(real, vector, vector)
+real logistic_ccdf_log(real, vector, row_vector)
+real logistic_ccdf_log(real, vector, real[])
+real logistic_ccdf_log(real, row_vector, real)
+real logistic_ccdf_log(real, row_vector, vector)
+real logistic_ccdf_log(real, row_vector, row_vector)
+real logistic_ccdf_log(real, row_vector, real[])
+real logistic_ccdf_log(real, real[], vector)
+real logistic_ccdf_log(real, real[], row_vector)
+real logistic_ccdf_log(vector, real, real)
+real logistic_ccdf_log(vector, real, vector)
+real logistic_ccdf_log(vector, real, row_vector)
+real logistic_ccdf_log(vector, real, real[])
+real logistic_ccdf_log(vector, vector, real)
+real logistic_ccdf_log(vector, vector, vector)
+real logistic_ccdf_log(vector, vector, row_vector)
+real logistic_ccdf_log(vector, vector, real[])
+real logistic_ccdf_log(vector, row_vector, real)
+real logistic_ccdf_log(vector, row_vector, vector)
+real logistic_ccdf_log(vector, row_vector, row_vector)
+real logistic_ccdf_log(vector, row_vector, real[])
+real logistic_ccdf_log(vector, real[], real)
+real logistic_ccdf_log(vector, real[], vector)
+real logistic_ccdf_log(vector, real[], row_vector)
+real logistic_ccdf_log(vector, real[], real[])
+real logistic_ccdf_log(row_vector, real, real)
+real logistic_ccdf_log(row_vector, real, vector)
+real logistic_ccdf_log(row_vector, real, row_vector)
+real logistic_ccdf_log(row_vector, real, real[])
+real logistic_ccdf_log(row_vector, vector, real)
+real logistic_ccdf_log(row_vector, vector, vector)
+real logistic_ccdf_log(row_vector, vector, row_vector)
+real logistic_ccdf_log(row_vector, vector, real[])
+real logistic_ccdf_log(row_vector, row_vector, real)
+real logistic_ccdf_log(row_vector, row_vector, vector)
+real logistic_ccdf_log(row_vector, row_vector, row_vector)
+real logistic_ccdf_log(row_vector, row_vector, real[])
+real logistic_ccdf_log(row_vector, real[], real)
+real logistic_ccdf_log(row_vector, real[], vector)
+real logistic_ccdf_log(row_vector, real[], row_vector)
+real logistic_ccdf_log(row_vector, real[], real[])
+real logistic_ccdf_log(real[], real, vector)
+real logistic_ccdf_log(real[], real, row_vector)
+real logistic_ccdf_log(real[], vector, real)
+real logistic_ccdf_log(real[], vector, vector)
+real logistic_ccdf_log(real[], vector, row_vector)
+real logistic_ccdf_log(real[], vector, real[])
+real logistic_ccdf_log(real[], row_vector, real)
+real logistic_ccdf_log(real[], row_vector, vector)
+real logistic_ccdf_log(real[], row_vector, row_vector)
+real logistic_ccdf_log(real[], row_vector, real[])
+real logistic_ccdf_log(real[], real[], vector)
+real logistic_ccdf_log(real[], real[], row_vector)
+real logistic_cdf(real, real, vector)
+real logistic_cdf(real, real, row_vector)
+real logistic_cdf(real, vector, real)
+real logistic_cdf(real, vector, vector)
+real logistic_cdf(real, vector, row_vector)
+real logistic_cdf(real, vector, real[])
+real logistic_cdf(real, row_vector, real)
+real logistic_cdf(real, row_vector, vector)
+real logistic_cdf(real, row_vector, row_vector)
+real logistic_cdf(real, row_vector, real[])
+real logistic_cdf(real, real[], vector)
+real logistic_cdf(real, real[], row_vector)
+real logistic_cdf(vector, real, real)
+real logistic_cdf(vector, real, vector)
+real logistic_cdf(vector, real, row_vector)
+real logistic_cdf(vector, real, real[])
+real logistic_cdf(vector, vector, real)
+real logistic_cdf(vector, vector, vector)
+real logistic_cdf(vector, vector, row_vector)
+real logistic_cdf(vector, vector, real[])
+real logistic_cdf(vector, row_vector, real)
+real logistic_cdf(vector, row_vector, vector)
+real logistic_cdf(vector, row_vector, row_vector)
+real logistic_cdf(vector, row_vector, real[])
+real logistic_cdf(vector, real[], real)
+real logistic_cdf(vector, real[], vector)
+real logistic_cdf(vector, real[], row_vector)
+real logistic_cdf(vector, real[], real[])
+real logistic_cdf(row_vector, real, real)
+real logistic_cdf(row_vector, real, vector)
+real logistic_cdf(row_vector, real, row_vector)
+real logistic_cdf(row_vector, real, real[])
+real logistic_cdf(row_vector, vector, real)
+real logistic_cdf(row_vector, vector, vector)
+real logistic_cdf(row_vector, vector, row_vector)
+real logistic_cdf(row_vector, vector, real[])
+real logistic_cdf(row_vector, row_vector, real)
+real logistic_cdf(row_vector, row_vector, vector)
+real logistic_cdf(row_vector, row_vector, row_vector)
+real logistic_cdf(row_vector, row_vector, real[])
+real logistic_cdf(row_vector, real[], real)
+real logistic_cdf(row_vector, real[], vector)
+real logistic_cdf(row_vector, real[], row_vector)
+real logistic_cdf(row_vector, real[], real[])
+real logistic_cdf(real[], real, vector)
+real logistic_cdf(real[], real, row_vector)
+real logistic_cdf(real[], vector, real)
+real logistic_cdf(real[], vector, vector)
+real logistic_cdf(real[], vector, row_vector)
+real logistic_cdf(real[], vector, real[])
+real logistic_cdf(real[], row_vector, real)
+real logistic_cdf(real[], row_vector, vector)
+real logistic_cdf(real[], row_vector, row_vector)
+real logistic_cdf(real[], row_vector, real[])
+real logistic_cdf(real[], real[], vector)
+real logistic_cdf(real[], real[], row_vector)
+real logistic_cdf_log(real, real, vector)
+real logistic_cdf_log(real, real, row_vector)
+real logistic_cdf_log(real, vector, real)
+real logistic_cdf_log(real, vector, vector)
+real logistic_cdf_log(real, vector, row_vector)
+real logistic_cdf_log(real, vector, real[])
+real logistic_cdf_log(real, row_vector, real)
+real logistic_cdf_log(real, row_vector, vector)
+real logistic_cdf_log(real, row_vector, row_vector)
+real logistic_cdf_log(real, row_vector, real[])
+real logistic_cdf_log(real, real[], vector)
+real logistic_cdf_log(real, real[], row_vector)
+real logistic_cdf_log(vector, real, real)
+real logistic_cdf_log(vector, real, vector)
+real logistic_cdf_log(vector, real, row_vector)
+real logistic_cdf_log(vector, real, real[])
+real logistic_cdf_log(vector, vector, real)
+real logistic_cdf_log(vector, vector, vector)
+real logistic_cdf_log(vector, vector, row_vector)
+real logistic_cdf_log(vector, vector, real[])
+real logistic_cdf_log(vector, row_vector, real)
+real logistic_cdf_log(vector, row_vector, vector)
+real logistic_cdf_log(vector, row_vector, row_vector)
+real logistic_cdf_log(vector, row_vector, real[])
+real logistic_cdf_log(vector, real[], real)
+real logistic_cdf_log(vector, real[], vector)
+real logistic_cdf_log(vector, real[], row_vector)
+real logistic_cdf_log(vector, real[], real[])
+real logistic_cdf_log(row_vector, real, real)
+real logistic_cdf_log(row_vector, real, vector)
+real logistic_cdf_log(row_vector, real, row_vector)
+real logistic_cdf_log(row_vector, real, real[])
+real logistic_cdf_log(row_vector, vector, real)
+real logistic_cdf_log(row_vector, vector, vector)
+real logistic_cdf_log(row_vector, vector, row_vector)
+real logistic_cdf_log(row_vector, vector, real[])
+real logistic_cdf_log(row_vector, row_vector, real)
+real logistic_cdf_log(row_vector, row_vector, vector)
+real logistic_cdf_log(row_vector, row_vector, row_vector)
+real logistic_cdf_log(row_vector, row_vector, real[])
+real logistic_cdf_log(row_vector, real[], real)
+real logistic_cdf_log(row_vector, real[], vector)
+real logistic_cdf_log(row_vector, real[], row_vector)
+real logistic_cdf_log(row_vector, real[], real[])
+real logistic_cdf_log(real[], real, vector)
+real logistic_cdf_log(real[], real, row_vector)
+real logistic_cdf_log(real[], vector, real)
+real logistic_cdf_log(real[], vector, vector)
+real logistic_cdf_log(real[], vector, row_vector)
+real logistic_cdf_log(real[], vector, real[])
+real logistic_cdf_log(real[], row_vector, real)
+real logistic_cdf_log(real[], row_vector, vector)
+real logistic_cdf_log(real[], row_vector, row_vector)
+real logistic_cdf_log(real[], row_vector, real[])
+real logistic_cdf_log(real[], real[], vector)
+real logistic_cdf_log(real[], real[], row_vector)
+real logistic_lccdf(real, real, vector)
+real logistic_lccdf(real, real, row_vector)
+real logistic_lccdf(real, vector, real)
+real logistic_lccdf(real, vector, vector)
+real logistic_lccdf(real, vector, row_vector)
+real logistic_lccdf(real, vector, real[])
+real logistic_lccdf(real, row_vector, real)
+real logistic_lccdf(real, row_vector, vector)
+real logistic_lccdf(real, row_vector, row_vector)
+real logistic_lccdf(real, row_vector, real[])
+real logistic_lccdf(real, real[], vector)
+real logistic_lccdf(real, real[], row_vector)
+real logistic_lccdf(vector, real, real)
+real logistic_lccdf(vector, real, vector)
+real logistic_lccdf(vector, real, row_vector)
+real logistic_lccdf(vector, real, real[])
+real logistic_lccdf(vector, vector, real)
+real logistic_lccdf(vector, vector, vector)
+real logistic_lccdf(vector, vector, row_vector)
+real logistic_lccdf(vector, vector, real[])
+real logistic_lccdf(vector, row_vector, real)
+real logistic_lccdf(vector, row_vector, vector)
+real logistic_lccdf(vector, row_vector, row_vector)
+real logistic_lccdf(vector, row_vector, real[])
+real logistic_lccdf(vector, real[], real)
+real logistic_lccdf(vector, real[], vector)
+real logistic_lccdf(vector, real[], row_vector)
+real logistic_lccdf(vector, real[], real[])
+real logistic_lccdf(row_vector, real, real)
+real logistic_lccdf(row_vector, real, vector)
+real logistic_lccdf(row_vector, real, row_vector)
+real logistic_lccdf(row_vector, real, real[])
+real logistic_lccdf(row_vector, vector, real)
+real logistic_lccdf(row_vector, vector, vector)
+real logistic_lccdf(row_vector, vector, row_vector)
+real logistic_lccdf(row_vector, vector, real[])
+real logistic_lccdf(row_vector, row_vector, real)
+real logistic_lccdf(row_vector, row_vector, vector)
+real logistic_lccdf(row_vector, row_vector, row_vector)
+real logistic_lccdf(row_vector, row_vector, real[])
+real logistic_lccdf(row_vector, real[], real)
+real logistic_lccdf(row_vector, real[], vector)
+real logistic_lccdf(row_vector, real[], row_vector)
+real logistic_lccdf(row_vector, real[], real[])
+real logistic_lccdf(real[], real, vector)
+real logistic_lccdf(real[], real, row_vector)
+real logistic_lccdf(real[], vector, real)
+real logistic_lccdf(real[], vector, vector)
+real logistic_lccdf(real[], vector, row_vector)
+real logistic_lccdf(real[], vector, real[])
+real logistic_lccdf(real[], row_vector, real)
+real logistic_lccdf(real[], row_vector, vector)
+real logistic_lccdf(real[], row_vector, row_vector)
+real logistic_lccdf(real[], row_vector, real[])
+real logistic_lccdf(real[], real[], vector)
+real logistic_lccdf(real[], real[], row_vector)
+real logistic_lcdf(real, real, vector)
+real logistic_lcdf(real, real, row_vector)
+real logistic_lcdf(real, vector, real)
+real logistic_lcdf(real, vector, vector)
+real logistic_lcdf(real, vector, row_vector)
+real logistic_lcdf(real, vector, real[])
+real logistic_lcdf(real, row_vector, real)
+real logistic_lcdf(real, row_vector, vector)
+real logistic_lcdf(real, row_vector, row_vector)
+real logistic_lcdf(real, row_vector, real[])
+real logistic_lcdf(real, real[], vector)
+real logistic_lcdf(real, real[], row_vector)
+real logistic_lcdf(vector, real, real)
+real logistic_lcdf(vector, real, vector)
+real logistic_lcdf(vector, real, row_vector)
+real logistic_lcdf(vector, real, real[])
+real logistic_lcdf(vector, vector, real)
+real logistic_lcdf(vector, vector, vector)
+real logistic_lcdf(vector, vector, row_vector)
+real logistic_lcdf(vector, vector, real[])
+real logistic_lcdf(vector, row_vector, real)
+real logistic_lcdf(vector, row_vector, vector)
+real logistic_lcdf(vector, row_vector, row_vector)
+real logistic_lcdf(vector, row_vector, real[])
+real logistic_lcdf(vector, real[], real)
+real logistic_lcdf(vector, real[], vector)
+real logistic_lcdf(vector, real[], row_vector)
+real logistic_lcdf(vector, real[], real[])
+real logistic_lcdf(row_vector, real, real)
+real logistic_lcdf(row_vector, real, vector)
+real logistic_lcdf(row_vector, real, row_vector)
+real logistic_lcdf(row_vector, real, real[])
+real logistic_lcdf(row_vector, vector, real)
+real logistic_lcdf(row_vector, vector, vector)
+real logistic_lcdf(row_vector, vector, row_vector)
+real logistic_lcdf(row_vector, vector, real[])
+real logistic_lcdf(row_vector, row_vector, real)
+real logistic_lcdf(row_vector, row_vector, vector)
+real logistic_lcdf(row_vector, row_vector, row_vector)
+real logistic_lcdf(row_vector, row_vector, real[])
+real logistic_lcdf(row_vector, real[], real)
+real logistic_lcdf(row_vector, real[], vector)
+real logistic_lcdf(row_vector, real[], row_vector)
+real logistic_lcdf(row_vector, real[], real[])
+real logistic_lcdf(real[], real, vector)
+real logistic_lcdf(real[], real, row_vector)
+real logistic_lcdf(real[], vector, real)
+real logistic_lcdf(real[], vector, vector)
+real logistic_lcdf(real[], vector, row_vector)
+real logistic_lcdf(real[], vector, real[])
+real logistic_lcdf(real[], row_vector, real)
+real logistic_lcdf(real[], row_vector, vector)
+real logistic_lcdf(real[], row_vector, row_vector)
+real logistic_lcdf(real[], row_vector, real[])
+real logistic_lcdf(real[], real[], vector)
+real logistic_lcdf(real[], real[], row_vector)
+real logistic_log(real, real, vector)
+real logistic_log(real, real, row_vector)
+real logistic_log(real, vector, real)
+real logistic_log(real, vector, vector)
+real logistic_log(real, vector, row_vector)
+real logistic_log(real, vector, real[])
+real logistic_log(real, row_vector, real)
+real logistic_log(real, row_vector, vector)
+real logistic_log(real, row_vector, row_vector)
+real logistic_log(real, row_vector, real[])
+real logistic_log(real, real[], vector)
+real logistic_log(real, real[], row_vector)
+real logistic_log(vector, real, real)
+real logistic_log(vector, real, vector)
+real logistic_log(vector, real, row_vector)
+real logistic_log(vector, real, real[])
+real logistic_log(vector, vector, real)
+real logistic_log(vector, vector, vector)
+real logistic_log(vector, vector, row_vector)
+real logistic_log(vector, vector, real[])
+real logistic_log(vector, row_vector, real)
+real logistic_log(vector, row_vector, vector)
+real logistic_log(vector, row_vector, row_vector)
+real logistic_log(vector, row_vector, real[])
+real logistic_log(vector, real[], real)
+real logistic_log(vector, real[], vector)
+real logistic_log(vector, real[], row_vector)
+real logistic_log(vector, real[], real[])
+real logistic_log(row_vector, real, real)
+real logistic_log(row_vector, real, vector)
+real logistic_log(row_vector, real, row_vector)
+real logistic_log(row_vector, real, real[])
+real logistic_log(row_vector, vector, real)
+real logistic_log(row_vector, vector, vector)
+real logistic_log(row_vector, vector, row_vector)
+real logistic_log(row_vector, vector, real[])
+real logistic_log(row_vector, row_vector, real)
+real logistic_log(row_vector, row_vector, vector)
+real logistic_log(row_vector, row_vector, row_vector)
+real logistic_log(row_vector, row_vector, real[])
+real logistic_log(row_vector, real[], real)
+real logistic_log(row_vector, real[], vector)
+real logistic_log(row_vector, real[], row_vector)
+real logistic_log(row_vector, real[], real[])
+real logistic_log(real[], real, vector)
+real logistic_log(real[], real, row_vector)
+real logistic_log(real[], vector, real)
+real logistic_log(real[], vector, vector)
+real logistic_log(real[], vector, row_vector)
+real logistic_log(real[], vector, real[])
+real logistic_log(real[], row_vector, real)
+real logistic_log(real[], row_vector, vector)
+real logistic_log(real[], row_vector, row_vector)
+real logistic_log(real[], row_vector, real[])
+real logistic_log(real[], real[], vector)
+real logistic_log(real[], real[], row_vector)
+real logistic_lpdf(real, real, vector)
+real logistic_lpdf(real, real, row_vector)
+real logistic_lpdf(real, vector, real)
+real logistic_lpdf(real, vector, vector)
+real logistic_lpdf(real, vector, row_vector)
+real logistic_lpdf(real, vector, real[])
+real logistic_lpdf(real, row_vector, real)
+real logistic_lpdf(real, row_vector, vector)
+real logistic_lpdf(real, row_vector, row_vector)
+real logistic_lpdf(real, row_vector, real[])
+real logistic_lpdf(real, real[], vector)
+real logistic_lpdf(real, real[], row_vector)
+real logistic_lpdf(vector, real, real)
+real logistic_lpdf(vector, real, vector)
+real logistic_lpdf(vector, real, row_vector)
+real logistic_lpdf(vector, real, real[])
+real logistic_lpdf(vector, vector, real)
+real logistic_lpdf(vector, vector, vector)
+real logistic_lpdf(vector, vector, row_vector)
+real logistic_lpdf(vector, vector, real[])
+real logistic_lpdf(vector, row_vector, real)
+real logistic_lpdf(vector, row_vector, vector)
+real logistic_lpdf(vector, row_vector, row_vector)
+real logistic_lpdf(vector, row_vector, real[])
+real logistic_lpdf(vector, real[], real)
+real logistic_lpdf(vector, real[], vector)
+real logistic_lpdf(vector, real[], row_vector)
+real logistic_lpdf(vector, real[], real[])
+real logistic_lpdf(row_vector, real, real)
+real logistic_lpdf(row_vector, real, vector)
+real logistic_lpdf(row_vector, real, row_vector)
+real logistic_lpdf(row_vector, real, real[])
+real logistic_lpdf(row_vector, vector, real)
+real logistic_lpdf(row_vector, vector, vector)
+real logistic_lpdf(row_vector, vector, row_vector)
+real logistic_lpdf(row_vector, vector, real[])
+real logistic_lpdf(row_vector, row_vector, real)
+real logistic_lpdf(row_vector, row_vector, vector)
+real logistic_lpdf(row_vector, row_vector, row_vector)
+real logistic_lpdf(row_vector, row_vector, real[])
+real logistic_lpdf(row_vector, real[], real)
+real logistic_lpdf(row_vector, real[], vector)
+real logistic_lpdf(row_vector, real[], row_vector)
+real logistic_lpdf(row_vector, real[], real[])
+real logistic_lpdf(real[], real, vector)
+real logistic_lpdf(real[], real, row_vector)
+real logistic_lpdf(real[], vector, real)
+real logistic_lpdf(real[], vector, vector)
+real logistic_lpdf(real[], vector, row_vector)
+real logistic_lpdf(real[], vector, real[])
+real logistic_lpdf(real[], row_vector, real)
+real logistic_lpdf(real[], row_vector, vector)
+real logistic_lpdf(real[], row_vector, row_vector)
+real logistic_lpdf(real[], row_vector, real[])
+real logistic_lpdf(real[], real[], vector)
+real logistic_lpdf(real[], real[], row_vector)
+real[] logistic_rng(int, vector)
+real[] logistic_rng(int, row_vector)
+real[] logistic_rng(real, vector)
+real[] logistic_rng(real, row_vector)
+real[] logistic_rng(vector, int)
+real[] logistic_rng(vector, real)
+real[] logistic_rng(vector, vector)
+real[] logistic_rng(vector, row_vector)
+real[] logistic_rng(vector, int[])
+real[] logistic_rng(vector, real[])
+real[] logistic_rng(row_vector, int)
+real[] logistic_rng(row_vector, real)
+real[] logistic_rng(row_vector, vector)
+real[] logistic_rng(row_vector, row_vector)
+real[] logistic_rng(row_vector, int[])
+real[] logistic_rng(row_vector, real[])
+real[] logistic_rng(int[], vector)
+real[] logistic_rng(int[], row_vector)
+real[] logistic_rng(real[], vector)
+real[] logistic_rng(real[], row_vector)
+real lognormal_ccdf_log(real, real, vector)
+real lognormal_ccdf_log(real, real, row_vector)
+real lognormal_ccdf_log(real, vector, real)
+real lognormal_ccdf_log(real, vector, vector)
+real lognormal_ccdf_log(real, vector, row_vector)
+real lognormal_ccdf_log(real, vector, real[])
+real lognormal_ccdf_log(real, row_vector, real)
+real lognormal_ccdf_log(real, row_vector, vector)
+real lognormal_ccdf_log(real, row_vector, row_vector)
+real lognormal_ccdf_log(real, row_vector, real[])
+real lognormal_ccdf_log(real, real[], vector)
+real lognormal_ccdf_log(real, real[], row_vector)
+real lognormal_ccdf_log(vector, real, real)
+real lognormal_ccdf_log(vector, real, vector)
+real lognormal_ccdf_log(vector, real, row_vector)
+real lognormal_ccdf_log(vector, real, real[])
+real lognormal_ccdf_log(vector, vector, real)
+real lognormal_ccdf_log(vector, vector, vector)
+real lognormal_ccdf_log(vector, vector, row_vector)
+real lognormal_ccdf_log(vector, vector, real[])
+real lognormal_ccdf_log(vector, row_vector, real)
+real lognormal_ccdf_log(vector, row_vector, vector)
+real lognormal_ccdf_log(vector, row_vector, row_vector)
+real lognormal_ccdf_log(vector, row_vector, real[])
+real lognormal_ccdf_log(vector, real[], real)
+real lognormal_ccdf_log(vector, real[], vector)
+real lognormal_ccdf_log(vector, real[], row_vector)
+real lognormal_ccdf_log(vector, real[], real[])
+real lognormal_ccdf_log(row_vector, real, real)
+real lognormal_ccdf_log(row_vector, real, vector)
+real lognormal_ccdf_log(row_vector, real, row_vector)
+real lognormal_ccdf_log(row_vector, real, real[])
+real lognormal_ccdf_log(row_vector, vector, real)
+real lognormal_ccdf_log(row_vector, vector, vector)
+real lognormal_ccdf_log(row_vector, vector, row_vector)
+real lognormal_ccdf_log(row_vector, vector, real[])
+real lognormal_ccdf_log(row_vector, row_vector, real)
+real lognormal_ccdf_log(row_vector, row_vector, vector)
+real lognormal_ccdf_log(row_vector, row_vector, row_vector)
+real lognormal_ccdf_log(row_vector, row_vector, real[])
+real lognormal_ccdf_log(row_vector, real[], real)
+real lognormal_ccdf_log(row_vector, real[], vector)
+real lognormal_ccdf_log(row_vector, real[], row_vector)
+real lognormal_ccdf_log(row_vector, real[], real[])
+real lognormal_ccdf_log(real[], real, vector)
+real lognormal_ccdf_log(real[], real, row_vector)
+real lognormal_ccdf_log(real[], vector, real)
+real lognormal_ccdf_log(real[], vector, vector)
+real lognormal_ccdf_log(real[], vector, row_vector)
+real lognormal_ccdf_log(real[], vector, real[])
+real lognormal_ccdf_log(real[], row_vector, real)
+real lognormal_ccdf_log(real[], row_vector, vector)
+real lognormal_ccdf_log(real[], row_vector, row_vector)
+real lognormal_ccdf_log(real[], row_vector, real[])
+real lognormal_ccdf_log(real[], real[], vector)
+real lognormal_ccdf_log(real[], real[], row_vector)
+real lognormal_cdf(real, real, vector)
+real lognormal_cdf(real, real, row_vector)
+real lognormal_cdf(real, vector, real)
+real lognormal_cdf(real, vector, vector)
+real lognormal_cdf(real, vector, row_vector)
+real lognormal_cdf(real, vector, real[])
+real lognormal_cdf(real, row_vector, real)
+real lognormal_cdf(real, row_vector, vector)
+real lognormal_cdf(real, row_vector, row_vector)
+real lognormal_cdf(real, row_vector, real[])
+real lognormal_cdf(real, real[], vector)
+real lognormal_cdf(real, real[], row_vector)
+real lognormal_cdf(vector, real, real)
+real lognormal_cdf(vector, real, vector)
+real lognormal_cdf(vector, real, row_vector)
+real lognormal_cdf(vector, real, real[])
+real lognormal_cdf(vector, vector, real)
+real lognormal_cdf(vector, vector, vector)
+real lognormal_cdf(vector, vector, row_vector)
+real lognormal_cdf(vector, vector, real[])
+real lognormal_cdf(vector, row_vector, real)
+real lognormal_cdf(vector, row_vector, vector)
+real lognormal_cdf(vector, row_vector, row_vector)
+real lognormal_cdf(vector, row_vector, real[])
+real lognormal_cdf(vector, real[], real)
+real lognormal_cdf(vector, real[], vector)
+real lognormal_cdf(vector, real[], row_vector)
+real lognormal_cdf(vector, real[], real[])
+real lognormal_cdf(row_vector, real, real)
+real lognormal_cdf(row_vector, real, vector)
+real lognormal_cdf(row_vector, real, row_vector)
+real lognormal_cdf(row_vector, real, real[])
+real lognormal_cdf(row_vector, vector, real)
+real lognormal_cdf(row_vector, vector, vector)
+real lognormal_cdf(row_vector, vector, row_vector)
+real lognormal_cdf(row_vector, vector, real[])
+real lognormal_cdf(row_vector, row_vector, real)
+real lognormal_cdf(row_vector, row_vector, vector)
+real lognormal_cdf(row_vector, row_vector, row_vector)
+real lognormal_cdf(row_vector, row_vector, real[])
+real lognormal_cdf(row_vector, real[], real)
+real lognormal_cdf(row_vector, real[], vector)
+real lognormal_cdf(row_vector, real[], row_vector)
+real lognormal_cdf(row_vector, real[], real[])
+real lognormal_cdf(real[], real, vector)
+real lognormal_cdf(real[], real, row_vector)
+real lognormal_cdf(real[], vector, real)
+real lognormal_cdf(real[], vector, vector)
+real lognormal_cdf(real[], vector, row_vector)
+real lognormal_cdf(real[], vector, real[])
+real lognormal_cdf(real[], row_vector, real)
+real lognormal_cdf(real[], row_vector, vector)
+real lognormal_cdf(real[], row_vector, row_vector)
+real lognormal_cdf(real[], row_vector, real[])
+real lognormal_cdf(real[], real[], vector)
+real lognormal_cdf(real[], real[], row_vector)
+real lognormal_cdf_log(real, real, vector)
+real lognormal_cdf_log(real, real, row_vector)
+real lognormal_cdf_log(real, vector, real)
+real lognormal_cdf_log(real, vector, vector)
+real lognormal_cdf_log(real, vector, row_vector)
+real lognormal_cdf_log(real, vector, real[])
+real lognormal_cdf_log(real, row_vector, real)
+real lognormal_cdf_log(real, row_vector, vector)
+real lognormal_cdf_log(real, row_vector, row_vector)
+real lognormal_cdf_log(real, row_vector, real[])
+real lognormal_cdf_log(real, real[], vector)
+real lognormal_cdf_log(real, real[], row_vector)
+real lognormal_cdf_log(vector, real, real)
+real lognormal_cdf_log(vector, real, vector)
+real lognormal_cdf_log(vector, real, row_vector)
+real lognormal_cdf_log(vector, real, real[])
+real lognormal_cdf_log(vector, vector, real)
+real lognormal_cdf_log(vector, vector, vector)
+real lognormal_cdf_log(vector, vector, row_vector)
+real lognormal_cdf_log(vector, vector, real[])
+real lognormal_cdf_log(vector, row_vector, real)
+real lognormal_cdf_log(vector, row_vector, vector)
+real lognormal_cdf_log(vector, row_vector, row_vector)
+real lognormal_cdf_log(vector, row_vector, real[])
+real lognormal_cdf_log(vector, real[], real)
+real lognormal_cdf_log(vector, real[], vector)
+real lognormal_cdf_log(vector, real[], row_vector)
+real lognormal_cdf_log(vector, real[], real[])
+real lognormal_cdf_log(row_vector, real, real)
+real lognormal_cdf_log(row_vector, real, vector)
+real lognormal_cdf_log(row_vector, real, row_vector)
+real lognormal_cdf_log(row_vector, real, real[])
+real lognormal_cdf_log(row_vector, vector, real)
+real lognormal_cdf_log(row_vector, vector, vector)
+real lognormal_cdf_log(row_vector, vector, row_vector)
+real lognormal_cdf_log(row_vector, vector, real[])
+real lognormal_cdf_log(row_vector, row_vector, real)
+real lognormal_cdf_log(row_vector, row_vector, vector)
+real lognormal_cdf_log(row_vector, row_vector, row_vector)
+real lognormal_cdf_log(row_vector, row_vector, real[])
+real lognormal_cdf_log(row_vector, real[], real)
+real lognormal_cdf_log(row_vector, real[], vector)
+real lognormal_cdf_log(row_vector, real[], row_vector)
+real lognormal_cdf_log(row_vector, real[], real[])
+real lognormal_cdf_log(real[], real, vector)
+real lognormal_cdf_log(real[], real, row_vector)
+real lognormal_cdf_log(real[], vector, real)
+real lognormal_cdf_log(real[], vector, vector)
+real lognormal_cdf_log(real[], vector, row_vector)
+real lognormal_cdf_log(real[], vector, real[])
+real lognormal_cdf_log(real[], row_vector, real)
+real lognormal_cdf_log(real[], row_vector, vector)
+real lognormal_cdf_log(real[], row_vector, row_vector)
+real lognormal_cdf_log(real[], row_vector, real[])
+real lognormal_cdf_log(real[], real[], vector)
+real lognormal_cdf_log(real[], real[], row_vector)
+real lognormal_lccdf(real, real, vector)
+real lognormal_lccdf(real, real, row_vector)
+real lognormal_lccdf(real, vector, real)
+real lognormal_lccdf(real, vector, vector)
+real lognormal_lccdf(real, vector, row_vector)
+real lognormal_lccdf(real, vector, real[])
+real lognormal_lccdf(real, row_vector, real)
+real lognormal_lccdf(real, row_vector, vector)
+real lognormal_lccdf(real, row_vector, row_vector)
+real lognormal_lccdf(real, row_vector, real[])
+real lognormal_lccdf(real, real[], vector)
+real lognormal_lccdf(real, real[], row_vector)
+real lognormal_lccdf(vector, real, real)
+real lognormal_lccdf(vector, real, vector)
+real lognormal_lccdf(vector, real, row_vector)
+real lognormal_lccdf(vector, real, real[])
+real lognormal_lccdf(vector, vector, real)
+real lognormal_lccdf(vector, vector, vector)
+real lognormal_lccdf(vector, vector, row_vector)
+real lognormal_lccdf(vector, vector, real[])
+real lognormal_lccdf(vector, row_vector, real)
+real lognormal_lccdf(vector, row_vector, vector)
+real lognormal_lccdf(vector, row_vector, row_vector)
+real lognormal_lccdf(vector, row_vector, real[])
+real lognormal_lccdf(vector, real[], real)
+real lognormal_lccdf(vector, real[], vector)
+real lognormal_lccdf(vector, real[], row_vector)
+real lognormal_lccdf(vector, real[], real[])
+real lognormal_lccdf(row_vector, real, real)
+real lognormal_lccdf(row_vector, real, vector)
+real lognormal_lccdf(row_vector, real, row_vector)
+real lognormal_lccdf(row_vector, real, real[])
+real lognormal_lccdf(row_vector, vector, real)
+real lognormal_lccdf(row_vector, vector, vector)
+real lognormal_lccdf(row_vector, vector, row_vector)
+real lognormal_lccdf(row_vector, vector, real[])
+real lognormal_lccdf(row_vector, row_vector, real)
+real lognormal_lccdf(row_vector, row_vector, vector)
+real lognormal_lccdf(row_vector, row_vector, row_vector)
+real lognormal_lccdf(row_vector, row_vector, real[])
+real lognormal_lccdf(row_vector, real[], real)
+real lognormal_lccdf(row_vector, real[], vector)
+real lognormal_lccdf(row_vector, real[], row_vector)
+real lognormal_lccdf(row_vector, real[], real[])
+real lognormal_lccdf(real[], real, vector)
+real lognormal_lccdf(real[], real, row_vector)
+real lognormal_lccdf(real[], vector, real)
+real lognormal_lccdf(real[], vector, vector)
+real lognormal_lccdf(real[], vector, row_vector)
+real lognormal_lccdf(real[], vector, real[])
+real lognormal_lccdf(real[], row_vector, real)
+real lognormal_lccdf(real[], row_vector, vector)
+real lognormal_lccdf(real[], row_vector, row_vector)
+real lognormal_lccdf(real[], row_vector, real[])
+real lognormal_lccdf(real[], real[], vector)
+real lognormal_lccdf(real[], real[], row_vector)
+real lognormal_lcdf(real, real, vector)
+real lognormal_lcdf(real, real, row_vector)
+real lognormal_lcdf(real, vector, real)
+real lognormal_lcdf(real, vector, vector)
+real lognormal_lcdf(real, vector, row_vector)
+real lognormal_lcdf(real, vector, real[])
+real lognormal_lcdf(real, row_vector, real)
+real lognormal_lcdf(real, row_vector, vector)
+real lognormal_lcdf(real, row_vector, row_vector)
+real lognormal_lcdf(real, row_vector, real[])
+real lognormal_lcdf(real, real[], vector)
+real lognormal_lcdf(real, real[], row_vector)
+real lognormal_lcdf(vector, real, real)
+real lognormal_lcdf(vector, real, vector)
+real lognormal_lcdf(vector, real, row_vector)
+real lognormal_lcdf(vector, real, real[])
+real lognormal_lcdf(vector, vector, real)
+real lognormal_lcdf(vector, vector, vector)
+real lognormal_lcdf(vector, vector, row_vector)
+real lognormal_lcdf(vector, vector, real[])
+real lognormal_lcdf(vector, row_vector, real)
+real lognormal_lcdf(vector, row_vector, vector)
+real lognormal_lcdf(vector, row_vector, row_vector)
+real lognormal_lcdf(vector, row_vector, real[])
+real lognormal_lcdf(vector, real[], real)
+real lognormal_lcdf(vector, real[], vector)
+real lognormal_lcdf(vector, real[], row_vector)
+real lognormal_lcdf(vector, real[], real[])
+real lognormal_lcdf(row_vector, real, real)
+real lognormal_lcdf(row_vector, real, vector)
+real lognormal_lcdf(row_vector, real, row_vector)
+real lognormal_lcdf(row_vector, real, real[])
+real lognormal_lcdf(row_vector, vector, real)
+real lognormal_lcdf(row_vector, vector, vector)
+real lognormal_lcdf(row_vector, vector, row_vector)
+real lognormal_lcdf(row_vector, vector, real[])
+real lognormal_lcdf(row_vector, row_vector, real)
+real lognormal_lcdf(row_vector, row_vector, vector)
+real lognormal_lcdf(row_vector, row_vector, row_vector)
+real lognormal_lcdf(row_vector, row_vector, real[])
+real lognormal_lcdf(row_vector, real[], real)
+real lognormal_lcdf(row_vector, real[], vector)
+real lognormal_lcdf(row_vector, real[], row_vector)
+real lognormal_lcdf(row_vector, real[], real[])
+real lognormal_lcdf(real[], real, vector)
+real lognormal_lcdf(real[], real, row_vector)
+real lognormal_lcdf(real[], vector, real)
+real lognormal_lcdf(real[], vector, vector)
+real lognormal_lcdf(real[], vector, row_vector)
+real lognormal_lcdf(real[], vector, real[])
+real lognormal_lcdf(real[], row_vector, real)
+real lognormal_lcdf(real[], row_vector, vector)
+real lognormal_lcdf(real[], row_vector, row_vector)
+real lognormal_lcdf(real[], row_vector, real[])
+real lognormal_lcdf(real[], real[], vector)
+real lognormal_lcdf(real[], real[], row_vector)
+real lognormal_log(real, real, vector)
+real lognormal_log(real, real, row_vector)
+real lognormal_log(real, vector, real)
+real lognormal_log(real, vector, vector)
+real lognormal_log(real, vector, row_vector)
+real lognormal_log(real, vector, real[])
+real lognormal_log(real, row_vector, real)
+real lognormal_log(real, row_vector, vector)
+real lognormal_log(real, row_vector, row_vector)
+real lognormal_log(real, row_vector, real[])
+real lognormal_log(real, real[], vector)
+real lognormal_log(real, real[], row_vector)
+real lognormal_log(vector, real, real)
+real lognormal_log(vector, real, vector)
+real lognormal_log(vector, real, row_vector)
+real lognormal_log(vector, real, real[])
+real lognormal_log(vector, vector, real)
+real lognormal_log(vector, vector, vector)
+real lognormal_log(vector, vector, row_vector)
+real lognormal_log(vector, vector, real[])
+real lognormal_log(vector, row_vector, real)
+real lognormal_log(vector, row_vector, vector)
+real lognormal_log(vector, row_vector, row_vector)
+real lognormal_log(vector, row_vector, real[])
+real lognormal_log(vector, real[], real)
+real lognormal_log(vector, real[], vector)
+real lognormal_log(vector, real[], row_vector)
+real lognormal_log(vector, real[], real[])
+real lognormal_log(row_vector, real, real)
+real lognormal_log(row_vector, real, vector)
+real lognormal_log(row_vector, real, row_vector)
+real lognormal_log(row_vector, real, real[])
+real lognormal_log(row_vector, vector, real)
+real lognormal_log(row_vector, vector, vector)
+real lognormal_log(row_vector, vector, row_vector)
+real lognormal_log(row_vector, vector, real[])
+real lognormal_log(row_vector, row_vector, real)
+real lognormal_log(row_vector, row_vector, vector)
+real lognormal_log(row_vector, row_vector, row_vector)
+real lognormal_log(row_vector, row_vector, real[])
+real lognormal_log(row_vector, real[], real)
+real lognormal_log(row_vector, real[], vector)
+real lognormal_log(row_vector, real[], row_vector)
+real lognormal_log(row_vector, real[], real[])
+real lognormal_log(real[], real, vector)
+real lognormal_log(real[], real, row_vector)
+real lognormal_log(real[], vector, real)
+real lognormal_log(real[], vector, vector)
+real lognormal_log(real[], vector, row_vector)
+real lognormal_log(real[], vector, real[])
+real lognormal_log(real[], row_vector, real)
+real lognormal_log(real[], row_vector, vector)
+real lognormal_log(real[], row_vector, row_vector)
+real lognormal_log(real[], row_vector, real[])
+real lognormal_log(real[], real[], vector)
+real lognormal_log(real[], real[], row_vector)
+real lognormal_lpdf(real, real, vector)
+real lognormal_lpdf(real, real, row_vector)
+real lognormal_lpdf(real, vector, real)
+real lognormal_lpdf(real, vector, vector)
+real lognormal_lpdf(real, vector, row_vector)
+real lognormal_lpdf(real, vector, real[])
+real lognormal_lpdf(real, row_vector, real)
+real lognormal_lpdf(real, row_vector, vector)
+real lognormal_lpdf(real, row_vector, row_vector)
+real lognormal_lpdf(real, row_vector, real[])
+real lognormal_lpdf(real, real[], vector)
+real lognormal_lpdf(real, real[], row_vector)
+real lognormal_lpdf(vector, real, real)
+real lognormal_lpdf(vector, real, vector)
+real lognormal_lpdf(vector, real, row_vector)
+real lognormal_lpdf(vector, real, real[])
+real lognormal_lpdf(vector, vector, real)
+real lognormal_lpdf(vector, vector, vector)
+real lognormal_lpdf(vector, vector, row_vector)
+real lognormal_lpdf(vector, vector, real[])
+real lognormal_lpdf(vector, row_vector, real)
+real lognormal_lpdf(vector, row_vector, vector)
+real lognormal_lpdf(vector, row_vector, row_vector)
+real lognormal_lpdf(vector, row_vector, real[])
+real lognormal_lpdf(vector, real[], real)
+real lognormal_lpdf(vector, real[], vector)
+real lognormal_lpdf(vector, real[], row_vector)
+real lognormal_lpdf(vector, real[], real[])
+real lognormal_lpdf(row_vector, real, real)
+real lognormal_lpdf(row_vector, real, vector)
+real lognormal_lpdf(row_vector, real, row_vector)
+real lognormal_lpdf(row_vector, real, real[])
+real lognormal_lpdf(row_vector, vector, real)
+real lognormal_lpdf(row_vector, vector, vector)
+real lognormal_lpdf(row_vector, vector, row_vector)
+real lognormal_lpdf(row_vector, vector, real[])
+real lognormal_lpdf(row_vector, row_vector, real)
+real lognormal_lpdf(row_vector, row_vector, vector)
+real lognormal_lpdf(row_vector, row_vector, row_vector)
+real lognormal_lpdf(row_vector, row_vector, real[])
+real lognormal_lpdf(row_vector, real[], real)
+real lognormal_lpdf(row_vector, real[], vector)
+real lognormal_lpdf(row_vector, real[], row_vector)
+real lognormal_lpdf(row_vector, real[], real[])
+real lognormal_lpdf(real[], real, vector)
+real lognormal_lpdf(real[], real, row_vector)
+real lognormal_lpdf(real[], vector, real)
+real lognormal_lpdf(real[], vector, vector)
+real lognormal_lpdf(real[], vector, row_vector)
+real lognormal_lpdf(real[], vector, real[])
+real lognormal_lpdf(real[], row_vector, real)
+real lognormal_lpdf(real[], row_vector, vector)
+real lognormal_lpdf(real[], row_vector, row_vector)
+real lognormal_lpdf(real[], row_vector, real[])
+real lognormal_lpdf(real[], real[], vector)
+real lognormal_lpdf(real[], real[], row_vector)
+real[] lognormal_rng(int, vector)
+real[] lognormal_rng(int, row_vector)
+real[] lognormal_rng(real, vector)
+real[] lognormal_rng(real, row_vector)
+real[] lognormal_rng(vector, int)
+real[] lognormal_rng(vector, real)
+real[] lognormal_rng(vector, vector)
+real[] lognormal_rng(vector, row_vector)
+real[] lognormal_rng(vector, int[])
+real[] lognormal_rng(vector, real[])
+real[] lognormal_rng(row_vector, int)
+real[] lognormal_rng(row_vector, real)
+real[] lognormal_rng(row_vector, vector)
+real[] lognormal_rng(row_vector, row_vector)
+real[] lognormal_rng(row_vector, int[])
+real[] lognormal_rng(row_vector, real[])
+real[] lognormal_rng(int[], vector)
+real[] lognormal_rng(int[], row_vector)
+real[] lognormal_rng(real[], vector)
+real[] lognormal_rng(real[], row_vector)
+vector map_rect((vector, vector, data real[], data int[]) => vector, vector,
+                  vector[], real[,], int[,])
+matrix matrix_exp_multiply(matrix, matrix)
+real multi_gp_cholesky_log(matrix, matrix, vector)
+real multi_gp_cholesky_lpdf(matrix, matrix, vector)
+real multi_gp_log(matrix, matrix, vector)
+real multi_gp_lpdf(matrix, matrix, vector)
+real multi_normal_cholesky_log(vector, vector, matrix)
+real multi_normal_cholesky_log(vector, row_vector, matrix)
+real multi_normal_cholesky_log(vector, vector[], matrix)
+real multi_normal_cholesky_log(vector, row_vector[], matrix)
+real multi_normal_cholesky_log(row_vector, vector, matrix)
+real multi_normal_cholesky_log(row_vector, row_vector, matrix)
+real multi_normal_cholesky_log(row_vector, vector[], matrix)
+real multi_normal_cholesky_log(row_vector, row_vector[], matrix)
+real multi_normal_cholesky_log(vector[], vector, matrix)
+real multi_normal_cholesky_log(vector[], row_vector, matrix)
+real multi_normal_cholesky_log(vector[], vector[], matrix)
+real multi_normal_cholesky_log(vector[], row_vector[], matrix)
+real multi_normal_cholesky_log(row_vector[], vector, matrix)
+real multi_normal_cholesky_log(row_vector[], row_vector, matrix)
+real multi_normal_cholesky_log(row_vector[], vector[], matrix)
+real multi_normal_cholesky_log(row_vector[], row_vector[], matrix)
+real multi_normal_cholesky_lpdf(vector, vector, matrix)
+real multi_normal_cholesky_lpdf(vector, row_vector, matrix)
+real multi_normal_cholesky_lpdf(vector, vector[], matrix)
+real multi_normal_cholesky_lpdf(vector, row_vector[], matrix)
+real multi_normal_cholesky_lpdf(row_vector, vector, matrix)
+real multi_normal_cholesky_lpdf(row_vector, row_vector, matrix)
+real multi_normal_cholesky_lpdf(row_vector, vector[], matrix)
+real multi_normal_cholesky_lpdf(row_vector, row_vector[], matrix)
+real multi_normal_cholesky_lpdf(vector[], vector, matrix)
+real multi_normal_cholesky_lpdf(vector[], row_vector, matrix)
+real multi_normal_cholesky_lpdf(vector[], vector[], matrix)
+real multi_normal_cholesky_lpdf(vector[], row_vector[], matrix)
+real multi_normal_cholesky_lpdf(row_vector[], vector, matrix)
+real multi_normal_cholesky_lpdf(row_vector[], row_vector, matrix)
+real multi_normal_cholesky_lpdf(row_vector[], vector[], matrix)
+real multi_normal_cholesky_lpdf(row_vector[], row_vector[], matrix)
+vector multi_normal_cholesky_rng(vector, matrix)
+vector multi_normal_cholesky_rng(row_vector, matrix)
+vector[] multi_normal_cholesky_rng(vector[], matrix)
+vector[] multi_normal_cholesky_rng(row_vector[], matrix)
+real multi_normal_log(vector, vector, matrix)
+real multi_normal_log(vector, row_vector, matrix)
+real multi_normal_log(vector, vector[], matrix)
+real multi_normal_log(vector, row_vector[], matrix)
+real multi_normal_log(row_vector, vector, matrix)
+real multi_normal_log(row_vector, row_vector, matrix)
+real multi_normal_log(row_vector, vector[], matrix)
+real multi_normal_log(row_vector, row_vector[], matrix)
+real multi_normal_log(vector[], vector, matrix)
+real multi_normal_log(vector[], row_vector, matrix)
+real multi_normal_log(vector[], vector[], matrix)
+real multi_normal_log(vector[], row_vector[], matrix)
+real multi_normal_log(row_vector[], vector, matrix)
+real multi_normal_log(row_vector[], row_vector, matrix)
+real multi_normal_log(row_vector[], vector[], matrix)
+real multi_normal_log(row_vector[], row_vector[], matrix)
+real multi_normal_lpdf(vector, vector, matrix)
+real multi_normal_lpdf(vector, row_vector, matrix)
+real multi_normal_lpdf(vector, vector[], matrix)
+real multi_normal_lpdf(vector, row_vector[], matrix)
+real multi_normal_lpdf(row_vector, vector, matrix)
+real multi_normal_lpdf(row_vector, row_vector, matrix)
+real multi_normal_lpdf(row_vector, vector[], matrix)
+real multi_normal_lpdf(row_vector, row_vector[], matrix)
+real multi_normal_lpdf(vector[], vector, matrix)
+real multi_normal_lpdf(vector[], row_vector, matrix)
+real multi_normal_lpdf(vector[], vector[], matrix)
+real multi_normal_lpdf(vector[], row_vector[], matrix)
+real multi_normal_lpdf(row_vector[], vector, matrix)
+real multi_normal_lpdf(row_vector[], row_vector, matrix)
+real multi_normal_lpdf(row_vector[], vector[], matrix)
+real multi_normal_lpdf(row_vector[], row_vector[], matrix)
+real multi_normal_prec_log(vector, vector, matrix)
+real multi_normal_prec_log(vector, row_vector, matrix)
+real multi_normal_prec_log(vector, vector[], matrix)
+real multi_normal_prec_log(vector, row_vector[], matrix)
+real multi_normal_prec_log(row_vector, vector, matrix)
+real multi_normal_prec_log(row_vector, row_vector, matrix)
+real multi_normal_prec_log(row_vector, vector[], matrix)
+real multi_normal_prec_log(row_vector, row_vector[], matrix)
+real multi_normal_prec_log(vector[], vector, matrix)
+real multi_normal_prec_log(vector[], row_vector, matrix)
+real multi_normal_prec_log(vector[], vector[], matrix)
+real multi_normal_prec_log(vector[], row_vector[], matrix)
+real multi_normal_prec_log(row_vector[], vector, matrix)
+real multi_normal_prec_log(row_vector[], row_vector, matrix)
+real multi_normal_prec_log(row_vector[], vector[], matrix)
+real multi_normal_prec_log(row_vector[], row_vector[], matrix)
+real multi_normal_prec_lpdf(vector, vector, matrix)
+real multi_normal_prec_lpdf(vector, row_vector, matrix)
+real multi_normal_prec_lpdf(vector, vector[], matrix)
+real multi_normal_prec_lpdf(vector, row_vector[], matrix)
+real multi_normal_prec_lpdf(row_vector, vector, matrix)
+real multi_normal_prec_lpdf(row_vector, row_vector, matrix)
+real multi_normal_prec_lpdf(row_vector, vector[], matrix)
+real multi_normal_prec_lpdf(row_vector, row_vector[], matrix)
+real multi_normal_prec_lpdf(vector[], vector, matrix)
+real multi_normal_prec_lpdf(vector[], row_vector, matrix)
+real multi_normal_prec_lpdf(vector[], vector[], matrix)
+real multi_normal_prec_lpdf(vector[], row_vector[], matrix)
+real multi_normal_prec_lpdf(row_vector[], vector, matrix)
+real multi_normal_prec_lpdf(row_vector[], row_vector, matrix)
+real multi_normal_prec_lpdf(row_vector[], vector[], matrix)
+real multi_normal_prec_lpdf(row_vector[], row_vector[], matrix)
+vector multi_normal_rng(vector, matrix)
+vector multi_normal_rng(row_vector, matrix)
+vector[] multi_normal_rng(vector[], matrix)
+vector[] multi_normal_rng(row_vector[], matrix)
+real multi_student_t_log(vector, real, vector, matrix)
+real multi_student_t_log(vector, real, row_vector, matrix)
+real multi_student_t_log(vector, real, vector[], matrix)
+real multi_student_t_log(vector, real, row_vector[], matrix)
+real multi_student_t_log(row_vector, real, vector, matrix)
+real multi_student_t_log(row_vector, real, row_vector, matrix)
+real multi_student_t_log(row_vector, real, vector[], matrix)
+real multi_student_t_log(row_vector, real, row_vector[], matrix)
+real multi_student_t_log(vector[], real, vector, matrix)
+real multi_student_t_log(vector[], real, row_vector, matrix)
+real multi_student_t_log(vector[], real, vector[], matrix)
+real multi_student_t_log(vector[], real, row_vector[], matrix)
+real multi_student_t_log(row_vector[], real, vector, matrix)
+real multi_student_t_log(row_vector[], real, row_vector, matrix)
+real multi_student_t_log(row_vector[], real, vector[], matrix)
+real multi_student_t_log(row_vector[], real, row_vector[], matrix)
+real multi_student_t_lpdf(vector, real, vector, matrix)
+real multi_student_t_lpdf(vector, real, row_vector, matrix)
+real multi_student_t_lpdf(vector, real, vector[], matrix)
+real multi_student_t_lpdf(vector, real, row_vector[], matrix)
+real multi_student_t_lpdf(row_vector, real, vector, matrix)
+real multi_student_t_lpdf(row_vector, real, row_vector, matrix)
+real multi_student_t_lpdf(row_vector, real, vector[], matrix)
+real multi_student_t_lpdf(row_vector, real, row_vector[], matrix)
+real multi_student_t_lpdf(vector[], real, vector, matrix)
+real multi_student_t_lpdf(vector[], real, row_vector, matrix)
+real multi_student_t_lpdf(vector[], real, vector[], matrix)
+real multi_student_t_lpdf(vector[], real, row_vector[], matrix)
+real multi_student_t_lpdf(row_vector[], real, vector, matrix)
+real multi_student_t_lpdf(row_vector[], real, row_vector, matrix)
+real multi_student_t_lpdf(row_vector[], real, vector[], matrix)
+real multi_student_t_lpdf(row_vector[], real, row_vector[], matrix)
+vector multi_student_t_rng(real, vector, matrix)
+vector multi_student_t_rng(real, row_vector, matrix)
+vector[] multi_student_t_rng(real, vector[], matrix)
+vector[] multi_student_t_rng(real, row_vector[], matrix)
+real multinomial_log(int[], vector)
+real multinomial_lpmf(int[], vector)
+int[] multinomial_rng(vector, int)
+matrix multiply_lower_tri_self_transpose(matrix)
+real neg_binomial_2_ccdf_log(int, real, vector)
+real neg_binomial_2_ccdf_log(int, real, row_vector)
+real neg_binomial_2_ccdf_log(int, vector, real)
+real neg_binomial_2_ccdf_log(int, vector, vector)
+real neg_binomial_2_ccdf_log(int, vector, row_vector)
+real neg_binomial_2_ccdf_log(int, vector, real[])
+real neg_binomial_2_ccdf_log(int, row_vector, real)
+real neg_binomial_2_ccdf_log(int, row_vector, vector)
+real neg_binomial_2_ccdf_log(int, row_vector, row_vector)
+real neg_binomial_2_ccdf_log(int, row_vector, real[])
+real neg_binomial_2_ccdf_log(int, real[], vector)
+real neg_binomial_2_ccdf_log(int, real[], row_vector)
+real neg_binomial_2_ccdf_log(int[], real, vector)
+real neg_binomial_2_ccdf_log(int[], real, row_vector)
+real neg_binomial_2_ccdf_log(int[], vector, real)
+real neg_binomial_2_ccdf_log(int[], vector, vector)
+real neg_binomial_2_ccdf_log(int[], vector, row_vector)
+real neg_binomial_2_ccdf_log(int[], vector, real[])
+real neg_binomial_2_ccdf_log(int[], row_vector, real)
+real neg_binomial_2_ccdf_log(int[], row_vector, vector)
+real neg_binomial_2_ccdf_log(int[], row_vector, row_vector)
+real neg_binomial_2_ccdf_log(int[], row_vector, real[])
+real neg_binomial_2_ccdf_log(int[], real[], vector)
+real neg_binomial_2_ccdf_log(int[], real[], row_vector)
+real neg_binomial_2_cdf(int, real, vector)
+real neg_binomial_2_cdf(int, real, row_vector)
+real neg_binomial_2_cdf(int, vector, real)
+real neg_binomial_2_cdf(int, vector, vector)
+real neg_binomial_2_cdf(int, vector, row_vector)
+real neg_binomial_2_cdf(int, vector, real[])
+real neg_binomial_2_cdf(int, row_vector, real)
+real neg_binomial_2_cdf(int, row_vector, vector)
+real neg_binomial_2_cdf(int, row_vector, row_vector)
+real neg_binomial_2_cdf(int, row_vector, real[])
+real neg_binomial_2_cdf(int, real[], vector)
+real neg_binomial_2_cdf(int, real[], row_vector)
+real neg_binomial_2_cdf(int[], real, vector)
+real neg_binomial_2_cdf(int[], real, row_vector)
+real neg_binomial_2_cdf(int[], vector, real)
+real neg_binomial_2_cdf(int[], vector, vector)
+real neg_binomial_2_cdf(int[], vector, row_vector)
+real neg_binomial_2_cdf(int[], vector, real[])
+real neg_binomial_2_cdf(int[], row_vector, real)
+real neg_binomial_2_cdf(int[], row_vector, vector)
+real neg_binomial_2_cdf(int[], row_vector, row_vector)
+real neg_binomial_2_cdf(int[], row_vector, real[])
+real neg_binomial_2_cdf(int[], real[], vector)
+real neg_binomial_2_cdf(int[], real[], row_vector)
+real neg_binomial_2_cdf_log(int, real, vector)
+real neg_binomial_2_cdf_log(int, real, row_vector)
+real neg_binomial_2_cdf_log(int, vector, real)
+real neg_binomial_2_cdf_log(int, vector, vector)
+real neg_binomial_2_cdf_log(int, vector, row_vector)
+real neg_binomial_2_cdf_log(int, vector, real[])
+real neg_binomial_2_cdf_log(int, row_vector, real)
+real neg_binomial_2_cdf_log(int, row_vector, vector)
+real neg_binomial_2_cdf_log(int, row_vector, row_vector)
+real neg_binomial_2_cdf_log(int, row_vector, real[])
+real neg_binomial_2_cdf_log(int, real[], vector)
+real neg_binomial_2_cdf_log(int, real[], row_vector)
+real neg_binomial_2_cdf_log(int[], real, vector)
+real neg_binomial_2_cdf_log(int[], real, row_vector)
+real neg_binomial_2_cdf_log(int[], vector, real)
+real neg_binomial_2_cdf_log(int[], vector, vector)
+real neg_binomial_2_cdf_log(int[], vector, row_vector)
+real neg_binomial_2_cdf_log(int[], vector, real[])
+real neg_binomial_2_cdf_log(int[], row_vector, real)
+real neg_binomial_2_cdf_log(int[], row_vector, vector)
+real neg_binomial_2_cdf_log(int[], row_vector, row_vector)
+real neg_binomial_2_cdf_log(int[], row_vector, real[])
+real neg_binomial_2_cdf_log(int[], real[], vector)
+real neg_binomial_2_cdf_log(int[], real[], row_vector)
+real neg_binomial_2_lccdf(int, real, vector)
+real neg_binomial_2_lccdf(int, real, row_vector)
+real neg_binomial_2_lccdf(int, vector, real)
+real neg_binomial_2_lccdf(int, vector, vector)
+real neg_binomial_2_lccdf(int, vector, row_vector)
+real neg_binomial_2_lccdf(int, vector, real[])
+real neg_binomial_2_lccdf(int, row_vector, real)
+real neg_binomial_2_lccdf(int, row_vector, vector)
+real neg_binomial_2_lccdf(int, row_vector, row_vector)
+real neg_binomial_2_lccdf(int, row_vector, real[])
+real neg_binomial_2_lccdf(int, real[], vector)
+real neg_binomial_2_lccdf(int, real[], row_vector)
+real neg_binomial_2_lccdf(int[], real, vector)
+real neg_binomial_2_lccdf(int[], real, row_vector)
+real neg_binomial_2_lccdf(int[], vector, real)
+real neg_binomial_2_lccdf(int[], vector, vector)
+real neg_binomial_2_lccdf(int[], vector, row_vector)
+real neg_binomial_2_lccdf(int[], vector, real[])
+real neg_binomial_2_lccdf(int[], row_vector, real)
+real neg_binomial_2_lccdf(int[], row_vector, vector)
+real neg_binomial_2_lccdf(int[], row_vector, row_vector)
+real neg_binomial_2_lccdf(int[], row_vector, real[])
+real neg_binomial_2_lccdf(int[], real[], vector)
+real neg_binomial_2_lccdf(int[], real[], row_vector)
+real neg_binomial_2_lcdf(int, real, vector)
+real neg_binomial_2_lcdf(int, real, row_vector)
+real neg_binomial_2_lcdf(int, vector, real)
+real neg_binomial_2_lcdf(int, vector, vector)
+real neg_binomial_2_lcdf(int, vector, row_vector)
+real neg_binomial_2_lcdf(int, vector, real[])
+real neg_binomial_2_lcdf(int, row_vector, real)
+real neg_binomial_2_lcdf(int, row_vector, vector)
+real neg_binomial_2_lcdf(int, row_vector, row_vector)
+real neg_binomial_2_lcdf(int, row_vector, real[])
+real neg_binomial_2_lcdf(int, real[], vector)
+real neg_binomial_2_lcdf(int, real[], row_vector)
+real neg_binomial_2_lcdf(int[], real, vector)
+real neg_binomial_2_lcdf(int[], real, row_vector)
+real neg_binomial_2_lcdf(int[], vector, real)
+real neg_binomial_2_lcdf(int[], vector, vector)
+real neg_binomial_2_lcdf(int[], vector, row_vector)
+real neg_binomial_2_lcdf(int[], vector, real[])
+real neg_binomial_2_lcdf(int[], row_vector, real)
+real neg_binomial_2_lcdf(int[], row_vector, vector)
+real neg_binomial_2_lcdf(int[], row_vector, row_vector)
+real neg_binomial_2_lcdf(int[], row_vector, real[])
+real neg_binomial_2_lcdf(int[], real[], vector)
+real neg_binomial_2_lcdf(int[], real[], row_vector)
+real neg_binomial_2_log(int, real, vector)
+real neg_binomial_2_log(int, real, row_vector)
+real neg_binomial_2_log(int, vector, real)
+real neg_binomial_2_log(int, vector, vector)
+real neg_binomial_2_log(int, vector, row_vector)
+real neg_binomial_2_log(int, vector, real[])
+real neg_binomial_2_log(int, row_vector, real)
+real neg_binomial_2_log(int, row_vector, vector)
+real neg_binomial_2_log(int, row_vector, row_vector)
+real neg_binomial_2_log(int, row_vector, real[])
+real neg_binomial_2_log(int, real[], vector)
+real neg_binomial_2_log(int, real[], row_vector)
+real neg_binomial_2_log(int[], real, vector)
+real neg_binomial_2_log(int[], real, row_vector)
+real neg_binomial_2_log(int[], vector, real)
+real neg_binomial_2_log(int[], vector, vector)
+real neg_binomial_2_log(int[], vector, row_vector)
+real neg_binomial_2_log(int[], vector, real[])
+real neg_binomial_2_log(int[], row_vector, real)
+real neg_binomial_2_log(int[], row_vector, vector)
+real neg_binomial_2_log(int[], row_vector, row_vector)
+real neg_binomial_2_log(int[], row_vector, real[])
+real neg_binomial_2_log(int[], real[], vector)
+real neg_binomial_2_log(int[], real[], row_vector)
+real neg_binomial_2_log_log(int, real, vector)
+real neg_binomial_2_log_log(int, real, row_vector)
+real neg_binomial_2_log_log(int, vector, real)
+real neg_binomial_2_log_log(int, vector, vector)
+real neg_binomial_2_log_log(int, vector, row_vector)
+real neg_binomial_2_log_log(int, vector, real[])
+real neg_binomial_2_log_log(int, row_vector, real)
+real neg_binomial_2_log_log(int, row_vector, vector)
+real neg_binomial_2_log_log(int, row_vector, row_vector)
+real neg_binomial_2_log_log(int, row_vector, real[])
+real neg_binomial_2_log_log(int, real[], vector)
+real neg_binomial_2_log_log(int, real[], row_vector)
+real neg_binomial_2_log_log(int[], real, vector)
+real neg_binomial_2_log_log(int[], real, row_vector)
+real neg_binomial_2_log_log(int[], vector, real)
+real neg_binomial_2_log_log(int[], vector, vector)
+real neg_binomial_2_log_log(int[], vector, row_vector)
+real neg_binomial_2_log_log(int[], vector, real[])
+real neg_binomial_2_log_log(int[], row_vector, real)
+real neg_binomial_2_log_log(int[], row_vector, vector)
+real neg_binomial_2_log_log(int[], row_vector, row_vector)
+real neg_binomial_2_log_log(int[], row_vector, real[])
+real neg_binomial_2_log_log(int[], real[], vector)
+real neg_binomial_2_log_log(int[], real[], row_vector)
+real neg_binomial_2_log_lpmf(int, real, vector)
+real neg_binomial_2_log_lpmf(int, real, row_vector)
+real neg_binomial_2_log_lpmf(int, vector, real)
+real neg_binomial_2_log_lpmf(int, vector, vector)
+real neg_binomial_2_log_lpmf(int, vector, row_vector)
+real neg_binomial_2_log_lpmf(int, vector, real[])
+real neg_binomial_2_log_lpmf(int, row_vector, real)
+real neg_binomial_2_log_lpmf(int, row_vector, vector)
+real neg_binomial_2_log_lpmf(int, row_vector, row_vector)
+real neg_binomial_2_log_lpmf(int, row_vector, real[])
+real neg_binomial_2_log_lpmf(int, real[], vector)
+real neg_binomial_2_log_lpmf(int, real[], row_vector)
+real neg_binomial_2_log_lpmf(int[], real, vector)
+real neg_binomial_2_log_lpmf(int[], real, row_vector)
+real neg_binomial_2_log_lpmf(int[], vector, real)
+real neg_binomial_2_log_lpmf(int[], vector, vector)
+real neg_binomial_2_log_lpmf(int[], vector, row_vector)
+real neg_binomial_2_log_lpmf(int[], vector, real[])
+real neg_binomial_2_log_lpmf(int[], row_vector, real)
+real neg_binomial_2_log_lpmf(int[], row_vector, vector)
+real neg_binomial_2_log_lpmf(int[], row_vector, row_vector)
+real neg_binomial_2_log_lpmf(int[], row_vector, real[])
+real neg_binomial_2_log_lpmf(int[], real[], vector)
+real neg_binomial_2_log_lpmf(int[], real[], row_vector)
+int[] neg_binomial_2_log_rng(int, vector)
+int[] neg_binomial_2_log_rng(int, row_vector)
+int[] neg_binomial_2_log_rng(real, vector)
+int[] neg_binomial_2_log_rng(real, row_vector)
+int[] neg_binomial_2_log_rng(vector, int)
+int[] neg_binomial_2_log_rng(vector, real)
+int[] neg_binomial_2_log_rng(vector, vector)
+int[] neg_binomial_2_log_rng(vector, row_vector)
+int[] neg_binomial_2_log_rng(vector, int[])
+int[] neg_binomial_2_log_rng(vector, real[])
+int[] neg_binomial_2_log_rng(row_vector, int)
+int[] neg_binomial_2_log_rng(row_vector, real)
+int[] neg_binomial_2_log_rng(row_vector, vector)
+int[] neg_binomial_2_log_rng(row_vector, row_vector)
+int[] neg_binomial_2_log_rng(row_vector, int[])
+int[] neg_binomial_2_log_rng(row_vector, real[])
+int[] neg_binomial_2_log_rng(int[], vector)
+int[] neg_binomial_2_log_rng(int[], row_vector)
+int[] neg_binomial_2_log_rng(real[], vector)
+int[] neg_binomial_2_log_rng(real[], row_vector)
+real neg_binomial_2_lpmf(int, real, vector)
+real neg_binomial_2_lpmf(int, real, row_vector)
+real neg_binomial_2_lpmf(int, vector, real)
+real neg_binomial_2_lpmf(int, vector, vector)
+real neg_binomial_2_lpmf(int, vector, row_vector)
+real neg_binomial_2_lpmf(int, vector, real[])
+real neg_binomial_2_lpmf(int, row_vector, real)
+real neg_binomial_2_lpmf(int, row_vector, vector)
+real neg_binomial_2_lpmf(int, row_vector, row_vector)
+real neg_binomial_2_lpmf(int, row_vector, real[])
+real neg_binomial_2_lpmf(int, real[], vector)
+real neg_binomial_2_lpmf(int, real[], row_vector)
+real neg_binomial_2_lpmf(int[], real, vector)
+real neg_binomial_2_lpmf(int[], real, row_vector)
+real neg_binomial_2_lpmf(int[], vector, real)
+real neg_binomial_2_lpmf(int[], vector, vector)
+real neg_binomial_2_lpmf(int[], vector, row_vector)
+real neg_binomial_2_lpmf(int[], vector, real[])
+real neg_binomial_2_lpmf(int[], row_vector, real)
+real neg_binomial_2_lpmf(int[], row_vector, vector)
+real neg_binomial_2_lpmf(int[], row_vector, row_vector)
+real neg_binomial_2_lpmf(int[], row_vector, real[])
+real neg_binomial_2_lpmf(int[], real[], vector)
+real neg_binomial_2_lpmf(int[], real[], row_vector)
+int[] neg_binomial_2_rng(int, vector)
+int[] neg_binomial_2_rng(int, row_vector)
+int[] neg_binomial_2_rng(real, vector)
+int[] neg_binomial_2_rng(real, row_vector)
+int[] neg_binomial_2_rng(vector, int)
+int[] neg_binomial_2_rng(vector, real)
+int[] neg_binomial_2_rng(vector, vector)
+int[] neg_binomial_2_rng(vector, row_vector)
+int[] neg_binomial_2_rng(vector, int[])
+int[] neg_binomial_2_rng(vector, real[])
+int[] neg_binomial_2_rng(row_vector, int)
+int[] neg_binomial_2_rng(row_vector, real)
+int[] neg_binomial_2_rng(row_vector, vector)
+int[] neg_binomial_2_rng(row_vector, row_vector)
+int[] neg_binomial_2_rng(row_vector, int[])
+int[] neg_binomial_2_rng(row_vector, real[])
+int[] neg_binomial_2_rng(int[], vector)
+int[] neg_binomial_2_rng(int[], row_vector)
+int[] neg_binomial_2_rng(real[], vector)
+int[] neg_binomial_2_rng(real[], row_vector)
+real neg_binomial_ccdf_log(int, real, vector)
+real neg_binomial_ccdf_log(int, real, row_vector)
+real neg_binomial_ccdf_log(int, vector, real)
+real neg_binomial_ccdf_log(int, vector, vector)
+real neg_binomial_ccdf_log(int, vector, row_vector)
+real neg_binomial_ccdf_log(int, vector, real[])
+real neg_binomial_ccdf_log(int, row_vector, real)
+real neg_binomial_ccdf_log(int, row_vector, vector)
+real neg_binomial_ccdf_log(int, row_vector, row_vector)
+real neg_binomial_ccdf_log(int, row_vector, real[])
+real neg_binomial_ccdf_log(int, real[], vector)
+real neg_binomial_ccdf_log(int, real[], row_vector)
+real neg_binomial_ccdf_log(int[], real, vector)
+real neg_binomial_ccdf_log(int[], real, row_vector)
+real neg_binomial_ccdf_log(int[], vector, real)
+real neg_binomial_ccdf_log(int[], vector, vector)
+real neg_binomial_ccdf_log(int[], vector, row_vector)
+real neg_binomial_ccdf_log(int[], vector, real[])
+real neg_binomial_ccdf_log(int[], row_vector, real)
+real neg_binomial_ccdf_log(int[], row_vector, vector)
+real neg_binomial_ccdf_log(int[], row_vector, row_vector)
+real neg_binomial_ccdf_log(int[], row_vector, real[])
+real neg_binomial_ccdf_log(int[], real[], vector)
+real neg_binomial_ccdf_log(int[], real[], row_vector)
+real neg_binomial_cdf(int, real, vector)
+real neg_binomial_cdf(int, real, row_vector)
+real neg_binomial_cdf(int, vector, real)
+real neg_binomial_cdf(int, vector, vector)
+real neg_binomial_cdf(int, vector, row_vector)
+real neg_binomial_cdf(int, vector, real[])
+real neg_binomial_cdf(int, row_vector, real)
+real neg_binomial_cdf(int, row_vector, vector)
+real neg_binomial_cdf(int, row_vector, row_vector)
+real neg_binomial_cdf(int, row_vector, real[])
+real neg_binomial_cdf(int, real[], vector)
+real neg_binomial_cdf(int, real[], row_vector)
+real neg_binomial_cdf(int[], real, vector)
+real neg_binomial_cdf(int[], real, row_vector)
+real neg_binomial_cdf(int[], vector, real)
+real neg_binomial_cdf(int[], vector, vector)
+real neg_binomial_cdf(int[], vector, row_vector)
+real neg_binomial_cdf(int[], vector, real[])
+real neg_binomial_cdf(int[], row_vector, real)
+real neg_binomial_cdf(int[], row_vector, vector)
+real neg_binomial_cdf(int[], row_vector, row_vector)
+real neg_binomial_cdf(int[], row_vector, real[])
+real neg_binomial_cdf(int[], real[], vector)
+real neg_binomial_cdf(int[], real[], row_vector)
+real neg_binomial_cdf_log(int, real, vector)
+real neg_binomial_cdf_log(int, real, row_vector)
+real neg_binomial_cdf_log(int, vector, real)
+real neg_binomial_cdf_log(int, vector, vector)
+real neg_binomial_cdf_log(int, vector, row_vector)
+real neg_binomial_cdf_log(int, vector, real[])
+real neg_binomial_cdf_log(int, row_vector, real)
+real neg_binomial_cdf_log(int, row_vector, vector)
+real neg_binomial_cdf_log(int, row_vector, row_vector)
+real neg_binomial_cdf_log(int, row_vector, real[])
+real neg_binomial_cdf_log(int, real[], vector)
+real neg_binomial_cdf_log(int, real[], row_vector)
+real neg_binomial_cdf_log(int[], real, vector)
+real neg_binomial_cdf_log(int[], real, row_vector)
+real neg_binomial_cdf_log(int[], vector, real)
+real neg_binomial_cdf_log(int[], vector, vector)
+real neg_binomial_cdf_log(int[], vector, row_vector)
+real neg_binomial_cdf_log(int[], vector, real[])
+real neg_binomial_cdf_log(int[], row_vector, real)
+real neg_binomial_cdf_log(int[], row_vector, vector)
+real neg_binomial_cdf_log(int[], row_vector, row_vector)
+real neg_binomial_cdf_log(int[], row_vector, real[])
+real neg_binomial_cdf_log(int[], real[], vector)
+real neg_binomial_cdf_log(int[], real[], row_vector)
+real neg_binomial_lccdf(int, real, vector)
+real neg_binomial_lccdf(int, real, row_vector)
+real neg_binomial_lccdf(int, vector, real)
+real neg_binomial_lccdf(int, vector, vector)
+real neg_binomial_lccdf(int, vector, row_vector)
+real neg_binomial_lccdf(int, vector, real[])
+real neg_binomial_lccdf(int, row_vector, real)
+real neg_binomial_lccdf(int, row_vector, vector)
+real neg_binomial_lccdf(int, row_vector, row_vector)
+real neg_binomial_lccdf(int, row_vector, real[])
+real neg_binomial_lccdf(int, real[], vector)
+real neg_binomial_lccdf(int, real[], row_vector)
+real neg_binomial_lccdf(int[], real, vector)
+real neg_binomial_lccdf(int[], real, row_vector)
+real neg_binomial_lccdf(int[], vector, real)
+real neg_binomial_lccdf(int[], vector, vector)
+real neg_binomial_lccdf(int[], vector, row_vector)
+real neg_binomial_lccdf(int[], vector, real[])
+real neg_binomial_lccdf(int[], row_vector, real)
+real neg_binomial_lccdf(int[], row_vector, vector)
+real neg_binomial_lccdf(int[], row_vector, row_vector)
+real neg_binomial_lccdf(int[], row_vector, real[])
+real neg_binomial_lccdf(int[], real[], vector)
+real neg_binomial_lccdf(int[], real[], row_vector)
+real neg_binomial_lcdf(int, real, vector)
+real neg_binomial_lcdf(int, real, row_vector)
+real neg_binomial_lcdf(int, vector, real)
+real neg_binomial_lcdf(int, vector, vector)
+real neg_binomial_lcdf(int, vector, row_vector)
+real neg_binomial_lcdf(int, vector, real[])
+real neg_binomial_lcdf(int, row_vector, real)
+real neg_binomial_lcdf(int, row_vector, vector)
+real neg_binomial_lcdf(int, row_vector, row_vector)
+real neg_binomial_lcdf(int, row_vector, real[])
+real neg_binomial_lcdf(int, real[], vector)
+real neg_binomial_lcdf(int, real[], row_vector)
+real neg_binomial_lcdf(int[], real, vector)
+real neg_binomial_lcdf(int[], real, row_vector)
+real neg_binomial_lcdf(int[], vector, real)
+real neg_binomial_lcdf(int[], vector, vector)
+real neg_binomial_lcdf(int[], vector, row_vector)
+real neg_binomial_lcdf(int[], vector, real[])
+real neg_binomial_lcdf(int[], row_vector, real)
+real neg_binomial_lcdf(int[], row_vector, vector)
+real neg_binomial_lcdf(int[], row_vector, row_vector)
+real neg_binomial_lcdf(int[], row_vector, real[])
+real neg_binomial_lcdf(int[], real[], vector)
+real neg_binomial_lcdf(int[], real[], row_vector)
+real neg_binomial_log(int, real, vector)
+real neg_binomial_log(int, real, row_vector)
+real neg_binomial_log(int, vector, real)
+real neg_binomial_log(int, vector, vector)
+real neg_binomial_log(int, vector, row_vector)
+real neg_binomial_log(int, vector, real[])
+real neg_binomial_log(int, row_vector, real)
+real neg_binomial_log(int, row_vector, vector)
+real neg_binomial_log(int, row_vector, row_vector)
+real neg_binomial_log(int, row_vector, real[])
+real neg_binomial_log(int, real[], vector)
+real neg_binomial_log(int, real[], row_vector)
+real neg_binomial_log(int[], real, vector)
+real neg_binomial_log(int[], real, row_vector)
+real neg_binomial_log(int[], vector, real)
+real neg_binomial_log(int[], vector, vector)
+real neg_binomial_log(int[], vector, row_vector)
+real neg_binomial_log(int[], vector, real[])
+real neg_binomial_log(int[], row_vector, real)
+real neg_binomial_log(int[], row_vector, vector)
+real neg_binomial_log(int[], row_vector, row_vector)
+real neg_binomial_log(int[], row_vector, real[])
+real neg_binomial_log(int[], real[], vector)
+real neg_binomial_log(int[], real[], row_vector)
+real neg_binomial_lpmf(int, real, vector)
+real neg_binomial_lpmf(int, real, row_vector)
+real neg_binomial_lpmf(int, vector, real)
+real neg_binomial_lpmf(int, vector, vector)
+real neg_binomial_lpmf(int, vector, row_vector)
+real neg_binomial_lpmf(int, vector, real[])
+real neg_binomial_lpmf(int, row_vector, real)
+real neg_binomial_lpmf(int, row_vector, vector)
+real neg_binomial_lpmf(int, row_vector, row_vector)
+real neg_binomial_lpmf(int, row_vector, real[])
+real neg_binomial_lpmf(int, real[], vector)
+real neg_binomial_lpmf(int, real[], row_vector)
+real neg_binomial_lpmf(int[], real, vector)
+real neg_binomial_lpmf(int[], real, row_vector)
+real neg_binomial_lpmf(int[], vector, real)
+real neg_binomial_lpmf(int[], vector, vector)
+real neg_binomial_lpmf(int[], vector, row_vector)
+real neg_binomial_lpmf(int[], vector, real[])
+real neg_binomial_lpmf(int[], row_vector, real)
+real neg_binomial_lpmf(int[], row_vector, vector)
+real neg_binomial_lpmf(int[], row_vector, row_vector)
+real neg_binomial_lpmf(int[], row_vector, real[])
+real neg_binomial_lpmf(int[], real[], vector)
+real neg_binomial_lpmf(int[], real[], row_vector)
+int[] neg_binomial_rng(int, vector)
+int[] neg_binomial_rng(int, row_vector)
+int[] neg_binomial_rng(real, vector)
+int[] neg_binomial_rng(real, row_vector)
+int[] neg_binomial_rng(vector, int)
+int[] neg_binomial_rng(vector, real)
+int[] neg_binomial_rng(vector, vector)
+int[] neg_binomial_rng(vector, row_vector)
+int[] neg_binomial_rng(vector, int[])
+int[] neg_binomial_rng(vector, real[])
+int[] neg_binomial_rng(row_vector, int)
+int[] neg_binomial_rng(row_vector, real)
+int[] neg_binomial_rng(row_vector, vector)
+int[] neg_binomial_rng(row_vector, row_vector)
+int[] neg_binomial_rng(row_vector, int[])
+int[] neg_binomial_rng(row_vector, real[])
+int[] neg_binomial_rng(int[], vector)
+int[] neg_binomial_rng(int[], row_vector)
+int[] neg_binomial_rng(real[], vector)
+int[] neg_binomial_rng(real[], row_vector)
+real normal_ccdf_log(real, real, vector)
+real normal_ccdf_log(real, real, row_vector)
+real normal_ccdf_log(real, vector, real)
+real normal_ccdf_log(real, vector, vector)
+real normal_ccdf_log(real, vector, row_vector)
+real normal_ccdf_log(real, vector, real[])
+real normal_ccdf_log(real, row_vector, real)
+real normal_ccdf_log(real, row_vector, vector)
+real normal_ccdf_log(real, row_vector, row_vector)
+real normal_ccdf_log(real, row_vector, real[])
+real normal_ccdf_log(real, real[], vector)
+real normal_ccdf_log(real, real[], row_vector)
+real normal_ccdf_log(vector, real, real)
+real normal_ccdf_log(vector, real, vector)
+real normal_ccdf_log(vector, real, row_vector)
+real normal_ccdf_log(vector, real, real[])
+real normal_ccdf_log(vector, vector, real)
+real normal_ccdf_log(vector, vector, vector)
+real normal_ccdf_log(vector, vector, row_vector)
+real normal_ccdf_log(vector, vector, real[])
+real normal_ccdf_log(vector, row_vector, real)
+real normal_ccdf_log(vector, row_vector, vector)
+real normal_ccdf_log(vector, row_vector, row_vector)
+real normal_ccdf_log(vector, row_vector, real[])
+real normal_ccdf_log(vector, real[], real)
+real normal_ccdf_log(vector, real[], vector)
+real normal_ccdf_log(vector, real[], row_vector)
+real normal_ccdf_log(vector, real[], real[])
+real normal_ccdf_log(row_vector, real, real)
+real normal_ccdf_log(row_vector, real, vector)
+real normal_ccdf_log(row_vector, real, row_vector)
+real normal_ccdf_log(row_vector, real, real[])
+real normal_ccdf_log(row_vector, vector, real)
+real normal_ccdf_log(row_vector, vector, vector)
+real normal_ccdf_log(row_vector, vector, row_vector)
+real normal_ccdf_log(row_vector, vector, real[])
+real normal_ccdf_log(row_vector, row_vector, real)
+real normal_ccdf_log(row_vector, row_vector, vector)
+real normal_ccdf_log(row_vector, row_vector, row_vector)
+real normal_ccdf_log(row_vector, row_vector, real[])
+real normal_ccdf_log(row_vector, real[], real)
+real normal_ccdf_log(row_vector, real[], vector)
+real normal_ccdf_log(row_vector, real[], row_vector)
+real normal_ccdf_log(row_vector, real[], real[])
+real normal_ccdf_log(real[], real, vector)
+real normal_ccdf_log(real[], real, row_vector)
+real normal_ccdf_log(real[], vector, real)
+real normal_ccdf_log(real[], vector, vector)
+real normal_ccdf_log(real[], vector, row_vector)
+real normal_ccdf_log(real[], vector, real[])
+real normal_ccdf_log(real[], row_vector, real)
+real normal_ccdf_log(real[], row_vector, vector)
+real normal_ccdf_log(real[], row_vector, row_vector)
+real normal_ccdf_log(real[], row_vector, real[])
+real normal_ccdf_log(real[], real[], vector)
+real normal_ccdf_log(real[], real[], row_vector)
+real normal_cdf(real, real, vector)
+real normal_cdf(real, real, row_vector)
+real normal_cdf(real, vector, real)
+real normal_cdf(real, vector, vector)
+real normal_cdf(real, vector, row_vector)
+real normal_cdf(real, vector, real[])
+real normal_cdf(real, row_vector, real)
+real normal_cdf(real, row_vector, vector)
+real normal_cdf(real, row_vector, row_vector)
+real normal_cdf(real, row_vector, real[])
+real normal_cdf(real, real[], vector)
+real normal_cdf(real, real[], row_vector)
+real normal_cdf(vector, real, real)
+real normal_cdf(vector, real, vector)
+real normal_cdf(vector, real, row_vector)
+real normal_cdf(vector, real, real[])
+real normal_cdf(vector, vector, real)
+real normal_cdf(vector, vector, vector)
+real normal_cdf(vector, vector, row_vector)
+real normal_cdf(vector, vector, real[])
+real normal_cdf(vector, row_vector, real)
+real normal_cdf(vector, row_vector, vector)
+real normal_cdf(vector, row_vector, row_vector)
+real normal_cdf(vector, row_vector, real[])
+real normal_cdf(vector, real[], real)
+real normal_cdf(vector, real[], vector)
+real normal_cdf(vector, real[], row_vector)
+real normal_cdf(vector, real[], real[])
+real normal_cdf(row_vector, real, real)
+real normal_cdf(row_vector, real, vector)
+real normal_cdf(row_vector, real, row_vector)
+real normal_cdf(row_vector, real, real[])
+real normal_cdf(row_vector, vector, real)
+real normal_cdf(row_vector, vector, vector)
+real normal_cdf(row_vector, vector, row_vector)
+real normal_cdf(row_vector, vector, real[])
+real normal_cdf(row_vector, row_vector, real)
+real normal_cdf(row_vector, row_vector, vector)
+real normal_cdf(row_vector, row_vector, row_vector)
+real normal_cdf(row_vector, row_vector, real[])
+real normal_cdf(row_vector, real[], real)
+real normal_cdf(row_vector, real[], vector)
+real normal_cdf(row_vector, real[], row_vector)
+real normal_cdf(row_vector, real[], real[])
+real normal_cdf(real[], real, vector)
+real normal_cdf(real[], real, row_vector)
+real normal_cdf(real[], vector, real)
+real normal_cdf(real[], vector, vector)
+real normal_cdf(real[], vector, row_vector)
+real normal_cdf(real[], vector, real[])
+real normal_cdf(real[], row_vector, real)
+real normal_cdf(real[], row_vector, vector)
+real normal_cdf(real[], row_vector, row_vector)
+real normal_cdf(real[], row_vector, real[])
+real normal_cdf(real[], real[], vector)
+real normal_cdf(real[], real[], row_vector)
+real normal_cdf_log(real, real, vector)
+real normal_cdf_log(real, real, row_vector)
+real normal_cdf_log(real, vector, real)
+real normal_cdf_log(real, vector, vector)
+real normal_cdf_log(real, vector, row_vector)
+real normal_cdf_log(real, vector, real[])
+real normal_cdf_log(real, row_vector, real)
+real normal_cdf_log(real, row_vector, vector)
+real normal_cdf_log(real, row_vector, row_vector)
+real normal_cdf_log(real, row_vector, real[])
+real normal_cdf_log(real, real[], vector)
+real normal_cdf_log(real, real[], row_vector)
+real normal_cdf_log(vector, real, real)
+real normal_cdf_log(vector, real, vector)
+real normal_cdf_log(vector, real, row_vector)
+real normal_cdf_log(vector, real, real[])
+real normal_cdf_log(vector, vector, real)
+real normal_cdf_log(vector, vector, vector)
+real normal_cdf_log(vector, vector, row_vector)
+real normal_cdf_log(vector, vector, real[])
+real normal_cdf_log(vector, row_vector, real)
+real normal_cdf_log(vector, row_vector, vector)
+real normal_cdf_log(vector, row_vector, row_vector)
+real normal_cdf_log(vector, row_vector, real[])
+real normal_cdf_log(vector, real[], real)
+real normal_cdf_log(vector, real[], vector)
+real normal_cdf_log(vector, real[], row_vector)
+real normal_cdf_log(vector, real[], real[])
+real normal_cdf_log(row_vector, real, real)
+real normal_cdf_log(row_vector, real, vector)
+real normal_cdf_log(row_vector, real, row_vector)
+real normal_cdf_log(row_vector, real, real[])
+real normal_cdf_log(row_vector, vector, real)
+real normal_cdf_log(row_vector, vector, vector)
+real normal_cdf_log(row_vector, vector, row_vector)
+real normal_cdf_log(row_vector, vector, real[])
+real normal_cdf_log(row_vector, row_vector, real)
+real normal_cdf_log(row_vector, row_vector, vector)
+real normal_cdf_log(row_vector, row_vector, row_vector)
+real normal_cdf_log(row_vector, row_vector, real[])
+real normal_cdf_log(row_vector, real[], real)
+real normal_cdf_log(row_vector, real[], vector)
+real normal_cdf_log(row_vector, real[], row_vector)
+real normal_cdf_log(row_vector, real[], real[])
+real normal_cdf_log(real[], real, vector)
+real normal_cdf_log(real[], real, row_vector)
+real normal_cdf_log(real[], vector, real)
+real normal_cdf_log(real[], vector, vector)
+real normal_cdf_log(real[], vector, row_vector)
+real normal_cdf_log(real[], vector, real[])
+real normal_cdf_log(real[], row_vector, real)
+real normal_cdf_log(real[], row_vector, vector)
+real normal_cdf_log(real[], row_vector, row_vector)
+real normal_cdf_log(real[], row_vector, real[])
+real normal_cdf_log(real[], real[], vector)
+real normal_cdf_log(real[], real[], row_vector)
+real normal_lccdf(real, real, vector)
+real normal_lccdf(real, real, row_vector)
+real normal_lccdf(real, vector, real)
+real normal_lccdf(real, vector, vector)
+real normal_lccdf(real, vector, row_vector)
+real normal_lccdf(real, vector, real[])
+real normal_lccdf(real, row_vector, real)
+real normal_lccdf(real, row_vector, vector)
+real normal_lccdf(real, row_vector, row_vector)
+real normal_lccdf(real, row_vector, real[])
+real normal_lccdf(real, real[], vector)
+real normal_lccdf(real, real[], row_vector)
+real normal_lccdf(vector, real, real)
+real normal_lccdf(vector, real, vector)
+real normal_lccdf(vector, real, row_vector)
+real normal_lccdf(vector, real, real[])
+real normal_lccdf(vector, vector, real)
+real normal_lccdf(vector, vector, vector)
+real normal_lccdf(vector, vector, row_vector)
+real normal_lccdf(vector, vector, real[])
+real normal_lccdf(vector, row_vector, real)
+real normal_lccdf(vector, row_vector, vector)
+real normal_lccdf(vector, row_vector, row_vector)
+real normal_lccdf(vector, row_vector, real[])
+real normal_lccdf(vector, real[], real)
+real normal_lccdf(vector, real[], vector)
+real normal_lccdf(vector, real[], row_vector)
+real normal_lccdf(vector, real[], real[])
+real normal_lccdf(row_vector, real, real)
+real normal_lccdf(row_vector, real, vector)
+real normal_lccdf(row_vector, real, row_vector)
+real normal_lccdf(row_vector, real, real[])
+real normal_lccdf(row_vector, vector, real)
+real normal_lccdf(row_vector, vector, vector)
+real normal_lccdf(row_vector, vector, row_vector)
+real normal_lccdf(row_vector, vector, real[])
+real normal_lccdf(row_vector, row_vector, real)
+real normal_lccdf(row_vector, row_vector, vector)
+real normal_lccdf(row_vector, row_vector, row_vector)
+real normal_lccdf(row_vector, row_vector, real[])
+real normal_lccdf(row_vector, real[], real)
+real normal_lccdf(row_vector, real[], vector)
+real normal_lccdf(row_vector, real[], row_vector)
+real normal_lccdf(row_vector, real[], real[])
+real normal_lccdf(real[], real, vector)
+real normal_lccdf(real[], real, row_vector)
+real normal_lccdf(real[], vector, real)
+real normal_lccdf(real[], vector, vector)
+real normal_lccdf(real[], vector, row_vector)
+real normal_lccdf(real[], vector, real[])
+real normal_lccdf(real[], row_vector, real)
+real normal_lccdf(real[], row_vector, vector)
+real normal_lccdf(real[], row_vector, row_vector)
+real normal_lccdf(real[], row_vector, real[])
+real normal_lccdf(real[], real[], vector)
+real normal_lccdf(real[], real[], row_vector)
+real normal_lcdf(real, real, vector)
+real normal_lcdf(real, real, row_vector)
+real normal_lcdf(real, vector, real)
+real normal_lcdf(real, vector, vector)
+real normal_lcdf(real, vector, row_vector)
+real normal_lcdf(real, vector, real[])
+real normal_lcdf(real, row_vector, real)
+real normal_lcdf(real, row_vector, vector)
+real normal_lcdf(real, row_vector, row_vector)
+real normal_lcdf(real, row_vector, real[])
+real normal_lcdf(real, real[], vector)
+real normal_lcdf(real, real[], row_vector)
+real normal_lcdf(vector, real, real)
+real normal_lcdf(vector, real, vector)
+real normal_lcdf(vector, real, row_vector)
+real normal_lcdf(vector, real, real[])
+real normal_lcdf(vector, vector, real)
+real normal_lcdf(vector, vector, vector)
+real normal_lcdf(vector, vector, row_vector)
+real normal_lcdf(vector, vector, real[])
+real normal_lcdf(vector, row_vector, real)
+real normal_lcdf(vector, row_vector, vector)
+real normal_lcdf(vector, row_vector, row_vector)
+real normal_lcdf(vector, row_vector, real[])
+real normal_lcdf(vector, real[], real)
+real normal_lcdf(vector, real[], vector)
+real normal_lcdf(vector, real[], row_vector)
+real normal_lcdf(vector, real[], real[])
+real normal_lcdf(row_vector, real, real)
+real normal_lcdf(row_vector, real, vector)
+real normal_lcdf(row_vector, real, row_vector)
+real normal_lcdf(row_vector, real, real[])
+real normal_lcdf(row_vector, vector, real)
+real normal_lcdf(row_vector, vector, vector)
+real normal_lcdf(row_vector, vector, row_vector)
+real normal_lcdf(row_vector, vector, real[])
+real normal_lcdf(row_vector, row_vector, real)
+real normal_lcdf(row_vector, row_vector, vector)
+real normal_lcdf(row_vector, row_vector, row_vector)
+real normal_lcdf(row_vector, row_vector, real[])
+real normal_lcdf(row_vector, real[], real)
+real normal_lcdf(row_vector, real[], vector)
+real normal_lcdf(row_vector, real[], row_vector)
+real normal_lcdf(row_vector, real[], real[])
+real normal_lcdf(real[], real, vector)
+real normal_lcdf(real[], real, row_vector)
+real normal_lcdf(real[], vector, real)
+real normal_lcdf(real[], vector, vector)
+real normal_lcdf(real[], vector, row_vector)
+real normal_lcdf(real[], vector, real[])
+real normal_lcdf(real[], row_vector, real)
+real normal_lcdf(real[], row_vector, vector)
+real normal_lcdf(real[], row_vector, row_vector)
+real normal_lcdf(real[], row_vector, real[])
+real normal_lcdf(real[], real[], vector)
+real normal_lcdf(real[], real[], row_vector)
+real normal_log(real, real, vector)
+real normal_log(real, real, row_vector)
+real normal_log(real, vector, real)
+real normal_log(real, vector, vector)
+real normal_log(real, vector, row_vector)
+real normal_log(real, vector, real[])
+real normal_log(real, row_vector, real)
+real normal_log(real, row_vector, vector)
+real normal_log(real, row_vector, row_vector)
+real normal_log(real, row_vector, real[])
+real normal_log(real, real[], vector)
+real normal_log(real, real[], row_vector)
+real normal_log(vector, real, real)
+real normal_log(vector, real, vector)
+real normal_log(vector, real, row_vector)
+real normal_log(vector, real, real[])
+real normal_log(vector, vector, real)
+real normal_log(vector, vector, vector)
+real normal_log(vector, vector, row_vector)
+real normal_log(vector, vector, real[])
+real normal_log(vector, row_vector, real)
+real normal_log(vector, row_vector, vector)
+real normal_log(vector, row_vector, row_vector)
+real normal_log(vector, row_vector, real[])
+real normal_log(vector, real[], real)
+real normal_log(vector, real[], vector)
+real normal_log(vector, real[], row_vector)
+real normal_log(vector, real[], real[])
+real normal_log(row_vector, real, real)
+real normal_log(row_vector, real, vector)
+real normal_log(row_vector, real, row_vector)
+real normal_log(row_vector, real, real[])
+real normal_log(row_vector, vector, real)
+real normal_log(row_vector, vector, vector)
+real normal_log(row_vector, vector, row_vector)
+real normal_log(row_vector, vector, real[])
+real normal_log(row_vector, row_vector, real)
+real normal_log(row_vector, row_vector, vector)
+real normal_log(row_vector, row_vector, row_vector)
+real normal_log(row_vector, row_vector, real[])
+real normal_log(row_vector, real[], real)
+real normal_log(row_vector, real[], vector)
+real normal_log(row_vector, real[], row_vector)
+real normal_log(row_vector, real[], real[])
+real normal_log(real[], real, vector)
+real normal_log(real[], real, row_vector)
+real normal_log(real[], vector, real)
+real normal_log(real[], vector, vector)
+real normal_log(real[], vector, row_vector)
+real normal_log(real[], vector, real[])
+real normal_log(real[], row_vector, real)
+real normal_log(real[], row_vector, vector)
+real normal_log(real[], row_vector, row_vector)
+real normal_log(real[], row_vector, real[])
+real normal_log(real[], real[], vector)
+real normal_log(real[], real[], row_vector)
+real normal_lpdf(real, real, vector)
+real normal_lpdf(real, real, row_vector)
+real normal_lpdf(real, vector, real)
+real normal_lpdf(real, vector, vector)
+real normal_lpdf(real, vector, row_vector)
+real normal_lpdf(real, vector, real[])
+real normal_lpdf(real, row_vector, real)
+real normal_lpdf(real, row_vector, vector)
+real normal_lpdf(real, row_vector, row_vector)
+real normal_lpdf(real, row_vector, real[])
+real normal_lpdf(real, real[], vector)
+real normal_lpdf(real, real[], row_vector)
+real normal_lpdf(vector, real, real)
+real normal_lpdf(vector, real, vector)
+real normal_lpdf(vector, real, row_vector)
+real normal_lpdf(vector, real, real[])
+real normal_lpdf(vector, vector, real)
+real normal_lpdf(vector, vector, vector)
+real normal_lpdf(vector, vector, row_vector)
+real normal_lpdf(vector, vector, real[])
+real normal_lpdf(vector, row_vector, real)
+real normal_lpdf(vector, row_vector, vector)
+real normal_lpdf(vector, row_vector, row_vector)
+real normal_lpdf(vector, row_vector, real[])
+real normal_lpdf(vector, real[], real)
+real normal_lpdf(vector, real[], vector)
+real normal_lpdf(vector, real[], row_vector)
+real normal_lpdf(vector, real[], real[])
+real normal_lpdf(row_vector, real, real)
+real normal_lpdf(row_vector, real, vector)
+real normal_lpdf(row_vector, real, row_vector)
+real normal_lpdf(row_vector, real, real[])
+real normal_lpdf(row_vector, vector, real)
+real normal_lpdf(row_vector, vector, vector)
+real normal_lpdf(row_vector, vector, row_vector)
+real normal_lpdf(row_vector, vector, real[])
+real normal_lpdf(row_vector, row_vector, real)
+real normal_lpdf(row_vector, row_vector, vector)
+real normal_lpdf(row_vector, row_vector, row_vector)
+real normal_lpdf(row_vector, row_vector, real[])
+real normal_lpdf(row_vector, real[], real)
+real normal_lpdf(row_vector, real[], vector)
+real normal_lpdf(row_vector, real[], row_vector)
+real normal_lpdf(row_vector, real[], real[])
+real normal_lpdf(real[], real, vector)
+real normal_lpdf(real[], real, row_vector)
+real normal_lpdf(real[], vector, real)
+real normal_lpdf(real[], vector, vector)
+real normal_lpdf(real[], vector, row_vector)
+real normal_lpdf(real[], vector, real[])
+real normal_lpdf(real[], row_vector, real)
+real normal_lpdf(real[], row_vector, vector)
+real normal_lpdf(real[], row_vector, row_vector)
+real normal_lpdf(real[], row_vector, real[])
+real normal_lpdf(real[], real[], vector)
+real normal_lpdf(real[], real[], row_vector)
+real[] normal_rng(int, vector)
+real[] normal_rng(int, row_vector)
+real[] normal_rng(real, vector)
+real[] normal_rng(real, row_vector)
+real[] normal_rng(vector, int)
+real[] normal_rng(vector, real)
+real[] normal_rng(vector, vector)
+real[] normal_rng(vector, row_vector)
+real[] normal_rng(vector, int[])
+real[] normal_rng(vector, real[])
+real[] normal_rng(row_vector, int)
+real[] normal_rng(row_vector, real)
+real[] normal_rng(row_vector, vector)
+real[] normal_rng(row_vector, row_vector)
+real[] normal_rng(row_vector, int[])
+real[] normal_rng(row_vector, real[])
+real[] normal_rng(int[], vector)
+real[] normal_rng(int[], row_vector)
+real[] normal_rng(real[], vector)
+real[] normal_rng(real[], row_vector)
+real ordered_logistic_log(int, real, vector)
+real ordered_logistic_log(int[], vector, vector)
+real ordered_logistic_log(int[], vector, vector[])
+real ordered_logistic_lpmf(int, real, vector)
+real ordered_logistic_lpmf(int[], vector, vector)
+real ordered_logistic_lpmf(int[], vector, vector[])
+int ordered_logistic_rng(real, vector)
+real ordered_probit_log(int, real, vector)
+real ordered_probit_log(int[], vector, vector)
+real ordered_probit_log(int[], vector, vector[])
+real ordered_probit_lpmf(int, real, vector)
+real ordered_probit_lpmf(int[], real, vector)
+real ordered_probit_lpmf(int[], real, vector[])
+int ordered_probit_rng(real, vector)
+real pareto_ccdf_log(real, real, vector)
+real pareto_ccdf_log(real, real, row_vector)
+real pareto_ccdf_log(real, vector, real)
+real pareto_ccdf_log(real, vector, vector)
+real pareto_ccdf_log(real, vector, row_vector)
+real pareto_ccdf_log(real, vector, real[])
+real pareto_ccdf_log(real, row_vector, real)
+real pareto_ccdf_log(real, row_vector, vector)
+real pareto_ccdf_log(real, row_vector, row_vector)
+real pareto_ccdf_log(real, row_vector, real[])
+real pareto_ccdf_log(real, real[], vector)
+real pareto_ccdf_log(real, real[], row_vector)
+real pareto_ccdf_log(vector, real, real)
+real pareto_ccdf_log(vector, real, vector)
+real pareto_ccdf_log(vector, real, row_vector)
+real pareto_ccdf_log(vector, real, real[])
+real pareto_ccdf_log(vector, vector, real)
+real pareto_ccdf_log(vector, vector, vector)
+real pareto_ccdf_log(vector, vector, row_vector)
+real pareto_ccdf_log(vector, vector, real[])
+real pareto_ccdf_log(vector, row_vector, real)
+real pareto_ccdf_log(vector, row_vector, vector)
+real pareto_ccdf_log(vector, row_vector, row_vector)
+real pareto_ccdf_log(vector, row_vector, real[])
+real pareto_ccdf_log(vector, real[], real)
+real pareto_ccdf_log(vector, real[], vector)
+real pareto_ccdf_log(vector, real[], row_vector)
+real pareto_ccdf_log(vector, real[], real[])
+real pareto_ccdf_log(row_vector, real, real)
+real pareto_ccdf_log(row_vector, real, vector)
+real pareto_ccdf_log(row_vector, real, row_vector)
+real pareto_ccdf_log(row_vector, real, real[])
+real pareto_ccdf_log(row_vector, vector, real)
+real pareto_ccdf_log(row_vector, vector, vector)
+real pareto_ccdf_log(row_vector, vector, row_vector)
+real pareto_ccdf_log(row_vector, vector, real[])
+real pareto_ccdf_log(row_vector, row_vector, real)
+real pareto_ccdf_log(row_vector, row_vector, vector)
+real pareto_ccdf_log(row_vector, row_vector, row_vector)
+real pareto_ccdf_log(row_vector, row_vector, real[])
+real pareto_ccdf_log(row_vector, real[], real)
+real pareto_ccdf_log(row_vector, real[], vector)
+real pareto_ccdf_log(row_vector, real[], row_vector)
+real pareto_ccdf_log(row_vector, real[], real[])
+real pareto_ccdf_log(real[], real, vector)
+real pareto_ccdf_log(real[], real, row_vector)
+real pareto_ccdf_log(real[], vector, real)
+real pareto_ccdf_log(real[], vector, vector)
+real pareto_ccdf_log(real[], vector, row_vector)
+real pareto_ccdf_log(real[], vector, real[])
+real pareto_ccdf_log(real[], row_vector, real)
+real pareto_ccdf_log(real[], row_vector, vector)
+real pareto_ccdf_log(real[], row_vector, row_vector)
+real pareto_ccdf_log(real[], row_vector, real[])
+real pareto_ccdf_log(real[], real[], vector)
+real pareto_ccdf_log(real[], real[], row_vector)
+real pareto_cdf(real, real, vector)
+real pareto_cdf(real, real, row_vector)
+real pareto_cdf(real, vector, real)
+real pareto_cdf(real, vector, vector)
+real pareto_cdf(real, vector, row_vector)
+real pareto_cdf(real, vector, real[])
+real pareto_cdf(real, row_vector, real)
+real pareto_cdf(real, row_vector, vector)
+real pareto_cdf(real, row_vector, row_vector)
+real pareto_cdf(real, row_vector, real[])
+real pareto_cdf(real, real[], vector)
+real pareto_cdf(real, real[], row_vector)
+real pareto_cdf(vector, real, real)
+real pareto_cdf(vector, real, vector)
+real pareto_cdf(vector, real, row_vector)
+real pareto_cdf(vector, real, real[])
+real pareto_cdf(vector, vector, real)
+real pareto_cdf(vector, vector, vector)
+real pareto_cdf(vector, vector, row_vector)
+real pareto_cdf(vector, vector, real[])
+real pareto_cdf(vector, row_vector, real)
+real pareto_cdf(vector, row_vector, vector)
+real pareto_cdf(vector, row_vector, row_vector)
+real pareto_cdf(vector, row_vector, real[])
+real pareto_cdf(vector, real[], real)
+real pareto_cdf(vector, real[], vector)
+real pareto_cdf(vector, real[], row_vector)
+real pareto_cdf(vector, real[], real[])
+real pareto_cdf(row_vector, real, real)
+real pareto_cdf(row_vector, real, vector)
+real pareto_cdf(row_vector, real, row_vector)
+real pareto_cdf(row_vector, real, real[])
+real pareto_cdf(row_vector, vector, real)
+real pareto_cdf(row_vector, vector, vector)
+real pareto_cdf(row_vector, vector, row_vector)
+real pareto_cdf(row_vector, vector, real[])
+real pareto_cdf(row_vector, row_vector, real)
+real pareto_cdf(row_vector, row_vector, vector)
+real pareto_cdf(row_vector, row_vector, row_vector)
+real pareto_cdf(row_vector, row_vector, real[])
+real pareto_cdf(row_vector, real[], real)
+real pareto_cdf(row_vector, real[], vector)
+real pareto_cdf(row_vector, real[], row_vector)
+real pareto_cdf(row_vector, real[], real[])
+real pareto_cdf(real[], real, vector)
+real pareto_cdf(real[], real, row_vector)
+real pareto_cdf(real[], vector, real)
+real pareto_cdf(real[], vector, vector)
+real pareto_cdf(real[], vector, row_vector)
+real pareto_cdf(real[], vector, real[])
+real pareto_cdf(real[], row_vector, real)
+real pareto_cdf(real[], row_vector, vector)
+real pareto_cdf(real[], row_vector, row_vector)
+real pareto_cdf(real[], row_vector, real[])
+real pareto_cdf(real[], real[], vector)
+real pareto_cdf(real[], real[], row_vector)
+real pareto_cdf_log(real, real, vector)
+real pareto_cdf_log(real, real, row_vector)
+real pareto_cdf_log(real, vector, real)
+real pareto_cdf_log(real, vector, vector)
+real pareto_cdf_log(real, vector, row_vector)
+real pareto_cdf_log(real, vector, real[])
+real pareto_cdf_log(real, row_vector, real)
+real pareto_cdf_log(real, row_vector, vector)
+real pareto_cdf_log(real, row_vector, row_vector)
+real pareto_cdf_log(real, row_vector, real[])
+real pareto_cdf_log(real, real[], vector)
+real pareto_cdf_log(real, real[], row_vector)
+real pareto_cdf_log(vector, real, real)
+real pareto_cdf_log(vector, real, vector)
+real pareto_cdf_log(vector, real, row_vector)
+real pareto_cdf_log(vector, real, real[])
+real pareto_cdf_log(vector, vector, real)
+real pareto_cdf_log(vector, vector, vector)
+real pareto_cdf_log(vector, vector, row_vector)
+real pareto_cdf_log(vector, vector, real[])
+real pareto_cdf_log(vector, row_vector, real)
+real pareto_cdf_log(vector, row_vector, vector)
+real pareto_cdf_log(vector, row_vector, row_vector)
+real pareto_cdf_log(vector, row_vector, real[])
+real pareto_cdf_log(vector, real[], real)
+real pareto_cdf_log(vector, real[], vector)
+real pareto_cdf_log(vector, real[], row_vector)
+real pareto_cdf_log(vector, real[], real[])
+real pareto_cdf_log(row_vector, real, real)
+real pareto_cdf_log(row_vector, real, vector)
+real pareto_cdf_log(row_vector, real, row_vector)
+real pareto_cdf_log(row_vector, real, real[])
+real pareto_cdf_log(row_vector, vector, real)
+real pareto_cdf_log(row_vector, vector, vector)
+real pareto_cdf_log(row_vector, vector, row_vector)
+real pareto_cdf_log(row_vector, vector, real[])
+real pareto_cdf_log(row_vector, row_vector, real)
+real pareto_cdf_log(row_vector, row_vector, vector)
+real pareto_cdf_log(row_vector, row_vector, row_vector)
+real pareto_cdf_log(row_vector, row_vector, real[])
+real pareto_cdf_log(row_vector, real[], real)
+real pareto_cdf_log(row_vector, real[], vector)
+real pareto_cdf_log(row_vector, real[], row_vector)
+real pareto_cdf_log(row_vector, real[], real[])
+real pareto_cdf_log(real[], real, vector)
+real pareto_cdf_log(real[], real, row_vector)
+real pareto_cdf_log(real[], vector, real)
+real pareto_cdf_log(real[], vector, vector)
+real pareto_cdf_log(real[], vector, row_vector)
+real pareto_cdf_log(real[], vector, real[])
+real pareto_cdf_log(real[], row_vector, real)
+real pareto_cdf_log(real[], row_vector, vector)
+real pareto_cdf_log(real[], row_vector, row_vector)
+real pareto_cdf_log(real[], row_vector, real[])
+real pareto_cdf_log(real[], real[], vector)
+real pareto_cdf_log(real[], real[], row_vector)
+real pareto_lccdf(real, real, vector)
+real pareto_lccdf(real, real, row_vector)
+real pareto_lccdf(real, vector, real)
+real pareto_lccdf(real, vector, vector)
+real pareto_lccdf(real, vector, row_vector)
+real pareto_lccdf(real, vector, real[])
+real pareto_lccdf(real, row_vector, real)
+real pareto_lccdf(real, row_vector, vector)
+real pareto_lccdf(real, row_vector, row_vector)
+real pareto_lccdf(real, row_vector, real[])
+real pareto_lccdf(real, real[], vector)
+real pareto_lccdf(real, real[], row_vector)
+real pareto_lccdf(vector, real, real)
+real pareto_lccdf(vector, real, vector)
+real pareto_lccdf(vector, real, row_vector)
+real pareto_lccdf(vector, real, real[])
+real pareto_lccdf(vector, vector, real)
+real pareto_lccdf(vector, vector, vector)
+real pareto_lccdf(vector, vector, row_vector)
+real pareto_lccdf(vector, vector, real[])
+real pareto_lccdf(vector, row_vector, real)
+real pareto_lccdf(vector, row_vector, vector)
+real pareto_lccdf(vector, row_vector, row_vector)
+real pareto_lccdf(vector, row_vector, real[])
+real pareto_lccdf(vector, real[], real)
+real pareto_lccdf(vector, real[], vector)
+real pareto_lccdf(vector, real[], row_vector)
+real pareto_lccdf(vector, real[], real[])
+real pareto_lccdf(row_vector, real, real)
+real pareto_lccdf(row_vector, real, vector)
+real pareto_lccdf(row_vector, real, row_vector)
+real pareto_lccdf(row_vector, real, real[])
+real pareto_lccdf(row_vector, vector, real)
+real pareto_lccdf(row_vector, vector, vector)
+real pareto_lccdf(row_vector, vector, row_vector)
+real pareto_lccdf(row_vector, vector, real[])
+real pareto_lccdf(row_vector, row_vector, real)
+real pareto_lccdf(row_vector, row_vector, vector)
+real pareto_lccdf(row_vector, row_vector, row_vector)
+real pareto_lccdf(row_vector, row_vector, real[])
+real pareto_lccdf(row_vector, real[], real)
+real pareto_lccdf(row_vector, real[], vector)
+real pareto_lccdf(row_vector, real[], row_vector)
+real pareto_lccdf(row_vector, real[], real[])
+real pareto_lccdf(real[], real, vector)
+real pareto_lccdf(real[], real, row_vector)
+real pareto_lccdf(real[], vector, real)
+real pareto_lccdf(real[], vector, vector)
+real pareto_lccdf(real[], vector, row_vector)
+real pareto_lccdf(real[], vector, real[])
+real pareto_lccdf(real[], row_vector, real)
+real pareto_lccdf(real[], row_vector, vector)
+real pareto_lccdf(real[], row_vector, row_vector)
+real pareto_lccdf(real[], row_vector, real[])
+real pareto_lccdf(real[], real[], vector)
+real pareto_lccdf(real[], real[], row_vector)
+real pareto_lcdf(real, real, vector)
+real pareto_lcdf(real, real, row_vector)
+real pareto_lcdf(real, vector, real)
+real pareto_lcdf(real, vector, vector)
+real pareto_lcdf(real, vector, row_vector)
+real pareto_lcdf(real, vector, real[])
+real pareto_lcdf(real, row_vector, real)
+real pareto_lcdf(real, row_vector, vector)
+real pareto_lcdf(real, row_vector, row_vector)
+real pareto_lcdf(real, row_vector, real[])
+real pareto_lcdf(real, real[], vector)
+real pareto_lcdf(real, real[], row_vector)
+real pareto_lcdf(vector, real, real)
+real pareto_lcdf(vector, real, vector)
+real pareto_lcdf(vector, real, row_vector)
+real pareto_lcdf(vector, real, real[])
+real pareto_lcdf(vector, vector, real)
+real pareto_lcdf(vector, vector, vector)
+real pareto_lcdf(vector, vector, row_vector)
+real pareto_lcdf(vector, vector, real[])
+real pareto_lcdf(vector, row_vector, real)
+real pareto_lcdf(vector, row_vector, vector)
+real pareto_lcdf(vector, row_vector, row_vector)
+real pareto_lcdf(vector, row_vector, real[])
+real pareto_lcdf(vector, real[], real)
+real pareto_lcdf(vector, real[], vector)
+real pareto_lcdf(vector, real[], row_vector)
+real pareto_lcdf(vector, real[], real[])
+real pareto_lcdf(row_vector, real, real)
+real pareto_lcdf(row_vector, real, vector)
+real pareto_lcdf(row_vector, real, row_vector)
+real pareto_lcdf(row_vector, real, real[])
+real pareto_lcdf(row_vector, vector, real)
+real pareto_lcdf(row_vector, vector, vector)
+real pareto_lcdf(row_vector, vector, row_vector)
+real pareto_lcdf(row_vector, vector, real[])
+real pareto_lcdf(row_vector, row_vector, real)
+real pareto_lcdf(row_vector, row_vector, vector)
+real pareto_lcdf(row_vector, row_vector, row_vector)
+real pareto_lcdf(row_vector, row_vector, real[])
+real pareto_lcdf(row_vector, real[], real)
+real pareto_lcdf(row_vector, real[], vector)
+real pareto_lcdf(row_vector, real[], row_vector)
+real pareto_lcdf(row_vector, real[], real[])
+real pareto_lcdf(real[], real, vector)
+real pareto_lcdf(real[], real, row_vector)
+real pareto_lcdf(real[], vector, real)
+real pareto_lcdf(real[], vector, vector)
+real pareto_lcdf(real[], vector, row_vector)
+real pareto_lcdf(real[], vector, real[])
+real pareto_lcdf(real[], row_vector, real)
+real pareto_lcdf(real[], row_vector, vector)
+real pareto_lcdf(real[], row_vector, row_vector)
+real pareto_lcdf(real[], row_vector, real[])
+real pareto_lcdf(real[], real[], vector)
+real pareto_lcdf(real[], real[], row_vector)
+real pareto_log(real, real, vector)
+real pareto_log(real, real, row_vector)
+real pareto_log(real, vector, real)
+real pareto_log(real, vector, vector)
+real pareto_log(real, vector, row_vector)
+real pareto_log(real, vector, real[])
+real pareto_log(real, row_vector, real)
+real pareto_log(real, row_vector, vector)
+real pareto_log(real, row_vector, row_vector)
+real pareto_log(real, row_vector, real[])
+real pareto_log(real, real[], vector)
+real pareto_log(real, real[], row_vector)
+real pareto_log(vector, real, real)
+real pareto_log(vector, real, vector)
+real pareto_log(vector, real, row_vector)
+real pareto_log(vector, real, real[])
+real pareto_log(vector, vector, real)
+real pareto_log(vector, vector, vector)
+real pareto_log(vector, vector, row_vector)
+real pareto_log(vector, vector, real[])
+real pareto_log(vector, row_vector, real)
+real pareto_log(vector, row_vector, vector)
+real pareto_log(vector, row_vector, row_vector)
+real pareto_log(vector, row_vector, real[])
+real pareto_log(vector, real[], real)
+real pareto_log(vector, real[], vector)
+real pareto_log(vector, real[], row_vector)
+real pareto_log(vector, real[], real[])
+real pareto_log(row_vector, real, real)
+real pareto_log(row_vector, real, vector)
+real pareto_log(row_vector, real, row_vector)
+real pareto_log(row_vector, real, real[])
+real pareto_log(row_vector, vector, real)
+real pareto_log(row_vector, vector, vector)
+real pareto_log(row_vector, vector, row_vector)
+real pareto_log(row_vector, vector, real[])
+real pareto_log(row_vector, row_vector, real)
+real pareto_log(row_vector, row_vector, vector)
+real pareto_log(row_vector, row_vector, row_vector)
+real pareto_log(row_vector, row_vector, real[])
+real pareto_log(row_vector, real[], real)
+real pareto_log(row_vector, real[], vector)
+real pareto_log(row_vector, real[], row_vector)
+real pareto_log(row_vector, real[], real[])
+real pareto_log(real[], real, vector)
+real pareto_log(real[], real, row_vector)
+real pareto_log(real[], vector, real)
+real pareto_log(real[], vector, vector)
+real pareto_log(real[], vector, row_vector)
+real pareto_log(real[], vector, real[])
+real pareto_log(real[], row_vector, real)
+real pareto_log(real[], row_vector, vector)
+real pareto_log(real[], row_vector, row_vector)
+real pareto_log(real[], row_vector, real[])
+real pareto_log(real[], real[], vector)
+real pareto_log(real[], real[], row_vector)
+real pareto_lpdf(real, real, vector)
+real pareto_lpdf(real, real, row_vector)
+real pareto_lpdf(real, vector, real)
+real pareto_lpdf(real, vector, vector)
+real pareto_lpdf(real, vector, row_vector)
+real pareto_lpdf(real, vector, real[])
+real pareto_lpdf(real, row_vector, real)
+real pareto_lpdf(real, row_vector, vector)
+real pareto_lpdf(real, row_vector, row_vector)
+real pareto_lpdf(real, row_vector, real[])
+real pareto_lpdf(real, real[], vector)
+real pareto_lpdf(real, real[], row_vector)
+real pareto_lpdf(vector, real, real)
+real pareto_lpdf(vector, real, vector)
+real pareto_lpdf(vector, real, row_vector)
+real pareto_lpdf(vector, real, real[])
+real pareto_lpdf(vector, vector, real)
+real pareto_lpdf(vector, vector, vector)
+real pareto_lpdf(vector, vector, row_vector)
+real pareto_lpdf(vector, vector, real[])
+real pareto_lpdf(vector, row_vector, real)
+real pareto_lpdf(vector, row_vector, vector)
+real pareto_lpdf(vector, row_vector, row_vector)
+real pareto_lpdf(vector, row_vector, real[])
+real pareto_lpdf(vector, real[], real)
+real pareto_lpdf(vector, real[], vector)
+real pareto_lpdf(vector, real[], row_vector)
+real pareto_lpdf(vector, real[], real[])
+real pareto_lpdf(row_vector, real, real)
+real pareto_lpdf(row_vector, real, vector)
+real pareto_lpdf(row_vector, real, row_vector)
+real pareto_lpdf(row_vector, real, real[])
+real pareto_lpdf(row_vector, vector, real)
+real pareto_lpdf(row_vector, vector, vector)
+real pareto_lpdf(row_vector, vector, row_vector)
+real pareto_lpdf(row_vector, vector, real[])
+real pareto_lpdf(row_vector, row_vector, real)
+real pareto_lpdf(row_vector, row_vector, vector)
+real pareto_lpdf(row_vector, row_vector, row_vector)
+real pareto_lpdf(row_vector, row_vector, real[])
+real pareto_lpdf(row_vector, real[], real)
+real pareto_lpdf(row_vector, real[], vector)
+real pareto_lpdf(row_vector, real[], row_vector)
+real pareto_lpdf(row_vector, real[], real[])
+real pareto_lpdf(real[], real, vector)
+real pareto_lpdf(real[], real, row_vector)
+real pareto_lpdf(real[], vector, real)
+real pareto_lpdf(real[], vector, vector)
+real pareto_lpdf(real[], vector, row_vector)
+real pareto_lpdf(real[], vector, real[])
+real pareto_lpdf(real[], row_vector, real)
+real pareto_lpdf(real[], row_vector, vector)
+real pareto_lpdf(real[], row_vector, row_vector)
+real pareto_lpdf(real[], row_vector, real[])
+real pareto_lpdf(real[], real[], vector)
+real pareto_lpdf(real[], real[], row_vector)
+real[] pareto_rng(int, vector)
+real[] pareto_rng(int, row_vector)
+real[] pareto_rng(real, vector)
+real[] pareto_rng(real, row_vector)
+real[] pareto_rng(vector, int)
+real[] pareto_rng(vector, real)
+real[] pareto_rng(vector, vector)
+real[] pareto_rng(vector, row_vector)
+real[] pareto_rng(vector, int[])
+real[] pareto_rng(vector, real[])
+real[] pareto_rng(row_vector, int)
+real[] pareto_rng(row_vector, real)
+real[] pareto_rng(row_vector, vector)
+real[] pareto_rng(row_vector, row_vector)
+real[] pareto_rng(row_vector, int[])
+real[] pareto_rng(row_vector, real[])
+real[] pareto_rng(int[], vector)
+real[] pareto_rng(int[], row_vector)
+real[] pareto_rng(real[], vector)
+real[] pareto_rng(real[], row_vector)
+real pareto_type_2_ccdf_log(real, real, real, vector)
+real pareto_type_2_ccdf_log(real, real, real, row_vector)
+real pareto_type_2_ccdf_log(real, real, vector, real)
+real pareto_type_2_ccdf_log(real, real, vector, vector)
+real pareto_type_2_ccdf_log(real, real, vector, row_vector)
+real pareto_type_2_ccdf_log(real, real, vector, real[])
+real pareto_type_2_ccdf_log(real, real, row_vector, real)
+real pareto_type_2_ccdf_log(real, real, row_vector, vector)
+real pareto_type_2_ccdf_log(real, real, row_vector, row_vector)
+real pareto_type_2_ccdf_log(real, real, row_vector, real[])
+real pareto_type_2_ccdf_log(real, real, real[], vector)
+real pareto_type_2_ccdf_log(real, real, real[], row_vector)
+real pareto_type_2_ccdf_log(real, vector, real, real)
+real pareto_type_2_ccdf_log(real, vector, real, vector)
+real pareto_type_2_ccdf_log(real, vector, real, row_vector)
+real pareto_type_2_ccdf_log(real, vector, real, real[])
+real pareto_type_2_ccdf_log(real, vector, vector, real)
+real pareto_type_2_ccdf_log(real, vector, vector, vector)
+real pareto_type_2_ccdf_log(real, vector, vector, row_vector)
+real pareto_type_2_ccdf_log(real, vector, vector, real[])
+real pareto_type_2_ccdf_log(real, vector, row_vector, real)
+real pareto_type_2_ccdf_log(real, vector, row_vector, vector)
+real pareto_type_2_ccdf_log(real, vector, row_vector, row_vector)
+real pareto_type_2_ccdf_log(real, vector, row_vector, real[])
+real pareto_type_2_ccdf_log(real, vector, real[], real)
+real pareto_type_2_ccdf_log(real, vector, real[], vector)
+real pareto_type_2_ccdf_log(real, vector, real[], row_vector)
+real pareto_type_2_ccdf_log(real, vector, real[], real[])
+real pareto_type_2_ccdf_log(real, row_vector, real, real)
+real pareto_type_2_ccdf_log(real, row_vector, real, vector)
+real pareto_type_2_ccdf_log(real, row_vector, real, row_vector)
+real pareto_type_2_ccdf_log(real, row_vector, real, real[])
+real pareto_type_2_ccdf_log(real, row_vector, vector, real)
+real pareto_type_2_ccdf_log(real, row_vector, vector, vector)
+real pareto_type_2_ccdf_log(real, row_vector, vector, row_vector)
+real pareto_type_2_ccdf_log(real, row_vector, vector, real[])
+real pareto_type_2_ccdf_log(real, row_vector, row_vector, real)
+real pareto_type_2_ccdf_log(real, row_vector, row_vector, vector)
+real pareto_type_2_ccdf_log(real, row_vector, row_vector, row_vector)
+real pareto_type_2_ccdf_log(real, row_vector, row_vector, real[])
+real pareto_type_2_ccdf_log(real, row_vector, real[], real)
+real pareto_type_2_ccdf_log(real, row_vector, real[], vector)
+real pareto_type_2_ccdf_log(real, row_vector, real[], row_vector)
+real pareto_type_2_ccdf_log(real, row_vector, real[], real[])
+real pareto_type_2_ccdf_log(real, real[], real, vector)
+real pareto_type_2_ccdf_log(real, real[], real, row_vector)
+real pareto_type_2_ccdf_log(real, real[], vector, real)
+real pareto_type_2_ccdf_log(real, real[], vector, vector)
+real pareto_type_2_ccdf_log(real, real[], vector, row_vector)
+real pareto_type_2_ccdf_log(real, real[], vector, real[])
+real pareto_type_2_ccdf_log(real, real[], row_vector, real)
+real pareto_type_2_ccdf_log(real, real[], row_vector, vector)
+real pareto_type_2_ccdf_log(real, real[], row_vector, row_vector)
+real pareto_type_2_ccdf_log(real, real[], row_vector, real[])
+real pareto_type_2_ccdf_log(real, real[], real[], vector)
+real pareto_type_2_ccdf_log(real, real[], real[], row_vector)
+real pareto_type_2_ccdf_log(vector, real, real, real)
+real pareto_type_2_ccdf_log(vector, real, real, vector)
+real pareto_type_2_ccdf_log(vector, real, real, row_vector)
+real pareto_type_2_ccdf_log(vector, real, real, real[])
+real pareto_type_2_ccdf_log(vector, real, vector, real)
+real pareto_type_2_ccdf_log(vector, real, vector, vector)
+real pareto_type_2_ccdf_log(vector, real, vector, row_vector)
+real pareto_type_2_ccdf_log(vector, real, vector, real[])
+real pareto_type_2_ccdf_log(vector, real, row_vector, real)
+real pareto_type_2_ccdf_log(vector, real, row_vector, vector)
+real pareto_type_2_ccdf_log(vector, real, row_vector, row_vector)
+real pareto_type_2_ccdf_log(vector, real, row_vector, real[])
+real pareto_type_2_ccdf_log(vector, real, real[], real)
+real pareto_type_2_ccdf_log(vector, real, real[], vector)
+real pareto_type_2_ccdf_log(vector, real, real[], row_vector)
+real pareto_type_2_ccdf_log(vector, real, real[], real[])
+real pareto_type_2_ccdf_log(vector, vector, real, real)
+real pareto_type_2_ccdf_log(vector, vector, real, vector)
+real pareto_type_2_ccdf_log(vector, vector, real, row_vector)
+real pareto_type_2_ccdf_log(vector, vector, real, real[])
+real pareto_type_2_ccdf_log(vector, vector, vector, real)
+real pareto_type_2_ccdf_log(vector, vector, vector, vector)
+real pareto_type_2_ccdf_log(vector, vector, vector, row_vector)
+real pareto_type_2_ccdf_log(vector, vector, vector, real[])
+real pareto_type_2_ccdf_log(vector, vector, row_vector, real)
+real pareto_type_2_ccdf_log(vector, vector, row_vector, vector)
+real pareto_type_2_ccdf_log(vector, vector, row_vector, row_vector)
+real pareto_type_2_ccdf_log(vector, vector, row_vector, real[])
+real pareto_type_2_ccdf_log(vector, vector, real[], real)
+real pareto_type_2_ccdf_log(vector, vector, real[], vector)
+real pareto_type_2_ccdf_log(vector, vector, real[], row_vector)
+real pareto_type_2_ccdf_log(vector, vector, real[], real[])
+real pareto_type_2_ccdf_log(vector, row_vector, real, real)
+real pareto_type_2_ccdf_log(vector, row_vector, real, vector)
+real pareto_type_2_ccdf_log(vector, row_vector, real, row_vector)
+real pareto_type_2_ccdf_log(vector, row_vector, real, real[])
+real pareto_type_2_ccdf_log(vector, row_vector, vector, real)
+real pareto_type_2_ccdf_log(vector, row_vector, vector, vector)
+real pareto_type_2_ccdf_log(vector, row_vector, vector, row_vector)
+real pareto_type_2_ccdf_log(vector, row_vector, vector, real[])
+real pareto_type_2_ccdf_log(vector, row_vector, row_vector, real)
+real pareto_type_2_ccdf_log(vector, row_vector, row_vector, vector)
+real pareto_type_2_ccdf_log(vector, row_vector, row_vector, row_vector)
+real pareto_type_2_ccdf_log(vector, row_vector, row_vector, real[])
+real pareto_type_2_ccdf_log(vector, row_vector, real[], real)
+real pareto_type_2_ccdf_log(vector, row_vector, real[], vector)
+real pareto_type_2_ccdf_log(vector, row_vector, real[], row_vector)
+real pareto_type_2_ccdf_log(vector, row_vector, real[], real[])
+real pareto_type_2_ccdf_log(vector, real[], real, real)
+real pareto_type_2_ccdf_log(vector, real[], real, vector)
+real pareto_type_2_ccdf_log(vector, real[], real, row_vector)
+real pareto_type_2_ccdf_log(vector, real[], real, real[])
+real pareto_type_2_ccdf_log(vector, real[], vector, real)
+real pareto_type_2_ccdf_log(vector, real[], vector, vector)
+real pareto_type_2_ccdf_log(vector, real[], vector, row_vector)
+real pareto_type_2_ccdf_log(vector, real[], vector, real[])
+real pareto_type_2_ccdf_log(vector, real[], row_vector, real)
+real pareto_type_2_ccdf_log(vector, real[], row_vector, vector)
+real pareto_type_2_ccdf_log(vector, real[], row_vector, row_vector)
+real pareto_type_2_ccdf_log(vector, real[], row_vector, real[])
+real pareto_type_2_ccdf_log(vector, real[], real[], real)
+real pareto_type_2_ccdf_log(vector, real[], real[], vector)
+real pareto_type_2_ccdf_log(vector, real[], real[], row_vector)
+real pareto_type_2_ccdf_log(vector, real[], real[], real[])
+real pareto_type_2_ccdf_log(row_vector, real, real, real)
+real pareto_type_2_ccdf_log(row_vector, real, real, vector)
+real pareto_type_2_ccdf_log(row_vector, real, real, row_vector)
+real pareto_type_2_ccdf_log(row_vector, real, real, real[])
+real pareto_type_2_ccdf_log(row_vector, real, vector, real)
+real pareto_type_2_ccdf_log(row_vector, real, vector, vector)
+real pareto_type_2_ccdf_log(row_vector, real, vector, row_vector)
+real pareto_type_2_ccdf_log(row_vector, real, vector, real[])
+real pareto_type_2_ccdf_log(row_vector, real, row_vector, real)
+real pareto_type_2_ccdf_log(row_vector, real, row_vector, vector)
+real pareto_type_2_ccdf_log(row_vector, real, row_vector, row_vector)
+real pareto_type_2_ccdf_log(row_vector, real, row_vector, real[])
+real pareto_type_2_ccdf_log(row_vector, real, real[], real)
+real pareto_type_2_ccdf_log(row_vector, real, real[], vector)
+real pareto_type_2_ccdf_log(row_vector, real, real[], row_vector)
+real pareto_type_2_ccdf_log(row_vector, real, real[], real[])
+real pareto_type_2_ccdf_log(row_vector, vector, real, real)
+real pareto_type_2_ccdf_log(row_vector, vector, real, vector)
+real pareto_type_2_ccdf_log(row_vector, vector, real, row_vector)
+real pareto_type_2_ccdf_log(row_vector, vector, real, real[])
+real pareto_type_2_ccdf_log(row_vector, vector, vector, real)
+real pareto_type_2_ccdf_log(row_vector, vector, vector, vector)
+real pareto_type_2_ccdf_log(row_vector, vector, vector, row_vector)
+real pareto_type_2_ccdf_log(row_vector, vector, vector, real[])
+real pareto_type_2_ccdf_log(row_vector, vector, row_vector, real)
+real pareto_type_2_ccdf_log(row_vector, vector, row_vector, vector)
+real pareto_type_2_ccdf_log(row_vector, vector, row_vector, row_vector)
+real pareto_type_2_ccdf_log(row_vector, vector, row_vector, real[])
+real pareto_type_2_ccdf_log(row_vector, vector, real[], real)
+real pareto_type_2_ccdf_log(row_vector, vector, real[], vector)
+real pareto_type_2_ccdf_log(row_vector, vector, real[], row_vector)
+real pareto_type_2_ccdf_log(row_vector, vector, real[], real[])
+real pareto_type_2_ccdf_log(row_vector, row_vector, real, real)
+real pareto_type_2_ccdf_log(row_vector, row_vector, real, vector)
+real pareto_type_2_ccdf_log(row_vector, row_vector, real, row_vector)
+real pareto_type_2_ccdf_log(row_vector, row_vector, real, real[])
+real pareto_type_2_ccdf_log(row_vector, row_vector, vector, real)
+real pareto_type_2_ccdf_log(row_vector, row_vector, vector, vector)
+real pareto_type_2_ccdf_log(row_vector, row_vector, vector, row_vector)
+real pareto_type_2_ccdf_log(row_vector, row_vector, vector, real[])
+real pareto_type_2_ccdf_log(row_vector, row_vector, row_vector, real)
+real pareto_type_2_ccdf_log(row_vector, row_vector, row_vector, vector)
+real pareto_type_2_ccdf_log(row_vector, row_vector, row_vector, row_vector)
+real pareto_type_2_ccdf_log(row_vector, row_vector, row_vector, real[])
+real pareto_type_2_ccdf_log(row_vector, row_vector, real[], real)
+real pareto_type_2_ccdf_log(row_vector, row_vector, real[], vector)
+real pareto_type_2_ccdf_log(row_vector, row_vector, real[], row_vector)
+real pareto_type_2_ccdf_log(row_vector, row_vector, real[], real[])
+real pareto_type_2_ccdf_log(row_vector, real[], real, real)
+real pareto_type_2_ccdf_log(row_vector, real[], real, vector)
+real pareto_type_2_ccdf_log(row_vector, real[], real, row_vector)
+real pareto_type_2_ccdf_log(row_vector, real[], real, real[])
+real pareto_type_2_ccdf_log(row_vector, real[], vector, real)
+real pareto_type_2_ccdf_log(row_vector, real[], vector, vector)
+real pareto_type_2_ccdf_log(row_vector, real[], vector, row_vector)
+real pareto_type_2_ccdf_log(row_vector, real[], vector, real[])
+real pareto_type_2_ccdf_log(row_vector, real[], row_vector, real)
+real pareto_type_2_ccdf_log(row_vector, real[], row_vector, vector)
+real pareto_type_2_ccdf_log(row_vector, real[], row_vector, row_vector)
+real pareto_type_2_ccdf_log(row_vector, real[], row_vector, real[])
+real pareto_type_2_ccdf_log(row_vector, real[], real[], real)
+real pareto_type_2_ccdf_log(row_vector, real[], real[], vector)
+real pareto_type_2_ccdf_log(row_vector, real[], real[], row_vector)
+real pareto_type_2_ccdf_log(row_vector, real[], real[], real[])
+real pareto_type_2_ccdf_log(real[], real, real, vector)
+real pareto_type_2_ccdf_log(real[], real, real, row_vector)
+real pareto_type_2_ccdf_log(real[], real, vector, real)
+real pareto_type_2_ccdf_log(real[], real, vector, vector)
+real pareto_type_2_ccdf_log(real[], real, vector, row_vector)
+real pareto_type_2_ccdf_log(real[], real, vector, real[])
+real pareto_type_2_ccdf_log(real[], real, row_vector, real)
+real pareto_type_2_ccdf_log(real[], real, row_vector, vector)
+real pareto_type_2_ccdf_log(real[], real, row_vector, row_vector)
+real pareto_type_2_ccdf_log(real[], real, row_vector, real[])
+real pareto_type_2_ccdf_log(real[], real, real[], vector)
+real pareto_type_2_ccdf_log(real[], real, real[], row_vector)
+real pareto_type_2_ccdf_log(real[], vector, real, real)
+real pareto_type_2_ccdf_log(real[], vector, real, vector)
+real pareto_type_2_ccdf_log(real[], vector, real, row_vector)
+real pareto_type_2_ccdf_log(real[], vector, real, real[])
+real pareto_type_2_ccdf_log(real[], vector, vector, real)
+real pareto_type_2_ccdf_log(real[], vector, vector, vector)
+real pareto_type_2_ccdf_log(real[], vector, vector, row_vector)
+real pareto_type_2_ccdf_log(real[], vector, vector, real[])
+real pareto_type_2_ccdf_log(real[], vector, row_vector, real)
+real pareto_type_2_ccdf_log(real[], vector, row_vector, vector)
+real pareto_type_2_ccdf_log(real[], vector, row_vector, row_vector)
+real pareto_type_2_ccdf_log(real[], vector, row_vector, real[])
+real pareto_type_2_ccdf_log(real[], vector, real[], real)
+real pareto_type_2_ccdf_log(real[], vector, real[], vector)
+real pareto_type_2_ccdf_log(real[], vector, real[], row_vector)
+real pareto_type_2_ccdf_log(real[], vector, real[], real[])
+real pareto_type_2_ccdf_log(real[], row_vector, real, real)
+real pareto_type_2_ccdf_log(real[], row_vector, real, vector)
+real pareto_type_2_ccdf_log(real[], row_vector, real, row_vector)
+real pareto_type_2_ccdf_log(real[], row_vector, real, real[])
+real pareto_type_2_ccdf_log(real[], row_vector, vector, real)
+real pareto_type_2_ccdf_log(real[], row_vector, vector, vector)
+real pareto_type_2_ccdf_log(real[], row_vector, vector, row_vector)
+real pareto_type_2_ccdf_log(real[], row_vector, vector, real[])
+real pareto_type_2_ccdf_log(real[], row_vector, row_vector, real)
+real pareto_type_2_ccdf_log(real[], row_vector, row_vector, vector)
+real pareto_type_2_ccdf_log(real[], row_vector, row_vector, row_vector)
+real pareto_type_2_ccdf_log(real[], row_vector, row_vector, real[])
+real pareto_type_2_ccdf_log(real[], row_vector, real[], real)
+real pareto_type_2_ccdf_log(real[], row_vector, real[], vector)
+real pareto_type_2_ccdf_log(real[], row_vector, real[], row_vector)
+real pareto_type_2_ccdf_log(real[], row_vector, real[], real[])
+real pareto_type_2_ccdf_log(real[], real[], real, vector)
+real pareto_type_2_ccdf_log(real[], real[], real, row_vector)
+real pareto_type_2_ccdf_log(real[], real[], vector, real)
+real pareto_type_2_ccdf_log(real[], real[], vector, vector)
+real pareto_type_2_ccdf_log(real[], real[], vector, row_vector)
+real pareto_type_2_ccdf_log(real[], real[], vector, real[])
+real pareto_type_2_ccdf_log(real[], real[], row_vector, real)
+real pareto_type_2_ccdf_log(real[], real[], row_vector, vector)
+real pareto_type_2_ccdf_log(real[], real[], row_vector, row_vector)
+real pareto_type_2_ccdf_log(real[], real[], row_vector, real[])
+real pareto_type_2_ccdf_log(real[], real[], real[], vector)
+real pareto_type_2_ccdf_log(real[], real[], real[], row_vector)
+real pareto_type_2_cdf(real, real, real, vector)
+real pareto_type_2_cdf(real, real, real, row_vector)
+real pareto_type_2_cdf(real, real, vector, real)
+real pareto_type_2_cdf(real, real, vector, vector)
+real pareto_type_2_cdf(real, real, vector, row_vector)
+real pareto_type_2_cdf(real, real, vector, real[])
+real pareto_type_2_cdf(real, real, row_vector, real)
+real pareto_type_2_cdf(real, real, row_vector, vector)
+real pareto_type_2_cdf(real, real, row_vector, row_vector)
+real pareto_type_2_cdf(real, real, row_vector, real[])
+real pareto_type_2_cdf(real, real, real[], vector)
+real pareto_type_2_cdf(real, real, real[], row_vector)
+real pareto_type_2_cdf(real, vector, real, real)
+real pareto_type_2_cdf(real, vector, real, vector)
+real pareto_type_2_cdf(real, vector, real, row_vector)
+real pareto_type_2_cdf(real, vector, real, real[])
+real pareto_type_2_cdf(real, vector, vector, real)
+real pareto_type_2_cdf(real, vector, vector, vector)
+real pareto_type_2_cdf(real, vector, vector, row_vector)
+real pareto_type_2_cdf(real, vector, vector, real[])
+real pareto_type_2_cdf(real, vector, row_vector, real)
+real pareto_type_2_cdf(real, vector, row_vector, vector)
+real pareto_type_2_cdf(real, vector, row_vector, row_vector)
+real pareto_type_2_cdf(real, vector, row_vector, real[])
+real pareto_type_2_cdf(real, vector, real[], real)
+real pareto_type_2_cdf(real, vector, real[], vector)
+real pareto_type_2_cdf(real, vector, real[], row_vector)
+real pareto_type_2_cdf(real, vector, real[], real[])
+real pareto_type_2_cdf(real, row_vector, real, real)
+real pareto_type_2_cdf(real, row_vector, real, vector)
+real pareto_type_2_cdf(real, row_vector, real, row_vector)
+real pareto_type_2_cdf(real, row_vector, real, real[])
+real pareto_type_2_cdf(real, row_vector, vector, real)
+real pareto_type_2_cdf(real, row_vector, vector, vector)
+real pareto_type_2_cdf(real, row_vector, vector, row_vector)
+real pareto_type_2_cdf(real, row_vector, vector, real[])
+real pareto_type_2_cdf(real, row_vector, row_vector, real)
+real pareto_type_2_cdf(real, row_vector, row_vector, vector)
+real pareto_type_2_cdf(real, row_vector, row_vector, row_vector)
+real pareto_type_2_cdf(real, row_vector, row_vector, real[])
+real pareto_type_2_cdf(real, row_vector, real[], real)
+real pareto_type_2_cdf(real, row_vector, real[], vector)
+real pareto_type_2_cdf(real, row_vector, real[], row_vector)
+real pareto_type_2_cdf(real, row_vector, real[], real[])
+real pareto_type_2_cdf(real, real[], real, vector)
+real pareto_type_2_cdf(real, real[], real, row_vector)
+real pareto_type_2_cdf(real, real[], vector, real)
+real pareto_type_2_cdf(real, real[], vector, vector)
+real pareto_type_2_cdf(real, real[], vector, row_vector)
+real pareto_type_2_cdf(real, real[], vector, real[])
+real pareto_type_2_cdf(real, real[], row_vector, real)
+real pareto_type_2_cdf(real, real[], row_vector, vector)
+real pareto_type_2_cdf(real, real[], row_vector, row_vector)
+real pareto_type_2_cdf(real, real[], row_vector, real[])
+real pareto_type_2_cdf(real, real[], real[], vector)
+real pareto_type_2_cdf(real, real[], real[], row_vector)
+real pareto_type_2_cdf(vector, real, real, real)
+real pareto_type_2_cdf(vector, real, real, vector)
+real pareto_type_2_cdf(vector, real, real, row_vector)
+real pareto_type_2_cdf(vector, real, real, real[])
+real pareto_type_2_cdf(vector, real, vector, real)
+real pareto_type_2_cdf(vector, real, vector, vector)
+real pareto_type_2_cdf(vector, real, vector, row_vector)
+real pareto_type_2_cdf(vector, real, vector, real[])
+real pareto_type_2_cdf(vector, real, row_vector, real)
+real pareto_type_2_cdf(vector, real, row_vector, vector)
+real pareto_type_2_cdf(vector, real, row_vector, row_vector)
+real pareto_type_2_cdf(vector, real, row_vector, real[])
+real pareto_type_2_cdf(vector, real, real[], real)
+real pareto_type_2_cdf(vector, real, real[], vector)
+real pareto_type_2_cdf(vector, real, real[], row_vector)
+real pareto_type_2_cdf(vector, real, real[], real[])
+real pareto_type_2_cdf(vector, vector, real, real)
+real pareto_type_2_cdf(vector, vector, real, vector)
+real pareto_type_2_cdf(vector, vector, real, row_vector)
+real pareto_type_2_cdf(vector, vector, real, real[])
+real pareto_type_2_cdf(vector, vector, vector, real)
+real pareto_type_2_cdf(vector, vector, vector, vector)
+real pareto_type_2_cdf(vector, vector, vector, row_vector)
+real pareto_type_2_cdf(vector, vector, vector, real[])
+real pareto_type_2_cdf(vector, vector, row_vector, real)
+real pareto_type_2_cdf(vector, vector, row_vector, vector)
+real pareto_type_2_cdf(vector, vector, row_vector, row_vector)
+real pareto_type_2_cdf(vector, vector, row_vector, real[])
+real pareto_type_2_cdf(vector, vector, real[], real)
+real pareto_type_2_cdf(vector, vector, real[], vector)
+real pareto_type_2_cdf(vector, vector, real[], row_vector)
+real pareto_type_2_cdf(vector, vector, real[], real[])
+real pareto_type_2_cdf(vector, row_vector, real, real)
+real pareto_type_2_cdf(vector, row_vector, real, vector)
+real pareto_type_2_cdf(vector, row_vector, real, row_vector)
+real pareto_type_2_cdf(vector, row_vector, real, real[])
+real pareto_type_2_cdf(vector, row_vector, vector, real)
+real pareto_type_2_cdf(vector, row_vector, vector, vector)
+real pareto_type_2_cdf(vector, row_vector, vector, row_vector)
+real pareto_type_2_cdf(vector, row_vector, vector, real[])
+real pareto_type_2_cdf(vector, row_vector, row_vector, real)
+real pareto_type_2_cdf(vector, row_vector, row_vector, vector)
+real pareto_type_2_cdf(vector, row_vector, row_vector, row_vector)
+real pareto_type_2_cdf(vector, row_vector, row_vector, real[])
+real pareto_type_2_cdf(vector, row_vector, real[], real)
+real pareto_type_2_cdf(vector, row_vector, real[], vector)
+real pareto_type_2_cdf(vector, row_vector, real[], row_vector)
+real pareto_type_2_cdf(vector, row_vector, real[], real[])
+real pareto_type_2_cdf(vector, real[], real, real)
+real pareto_type_2_cdf(vector, real[], real, vector)
+real pareto_type_2_cdf(vector, real[], real, row_vector)
+real pareto_type_2_cdf(vector, real[], real, real[])
+real pareto_type_2_cdf(vector, real[], vector, real)
+real pareto_type_2_cdf(vector, real[], vector, vector)
+real pareto_type_2_cdf(vector, real[], vector, row_vector)
+real pareto_type_2_cdf(vector, real[], vector, real[])
+real pareto_type_2_cdf(vector, real[], row_vector, real)
+real pareto_type_2_cdf(vector, real[], row_vector, vector)
+real pareto_type_2_cdf(vector, real[], row_vector, row_vector)
+real pareto_type_2_cdf(vector, real[], row_vector, real[])
+real pareto_type_2_cdf(vector, real[], real[], real)
+real pareto_type_2_cdf(vector, real[], real[], vector)
+real pareto_type_2_cdf(vector, real[], real[], row_vector)
+real pareto_type_2_cdf(vector, real[], real[], real[])
+real pareto_type_2_cdf(row_vector, real, real, real)
+real pareto_type_2_cdf(row_vector, real, real, vector)
+real pareto_type_2_cdf(row_vector, real, real, row_vector)
+real pareto_type_2_cdf(row_vector, real, real, real[])
+real pareto_type_2_cdf(row_vector, real, vector, real)
+real pareto_type_2_cdf(row_vector, real, vector, vector)
+real pareto_type_2_cdf(row_vector, real, vector, row_vector)
+real pareto_type_2_cdf(row_vector, real, vector, real[])
+real pareto_type_2_cdf(row_vector, real, row_vector, real)
+real pareto_type_2_cdf(row_vector, real, row_vector, vector)
+real pareto_type_2_cdf(row_vector, real, row_vector, row_vector)
+real pareto_type_2_cdf(row_vector, real, row_vector, real[])
+real pareto_type_2_cdf(row_vector, real, real[], real)
+real pareto_type_2_cdf(row_vector, real, real[], vector)
+real pareto_type_2_cdf(row_vector, real, real[], row_vector)
+real pareto_type_2_cdf(row_vector, real, real[], real[])
+real pareto_type_2_cdf(row_vector, vector, real, real)
+real pareto_type_2_cdf(row_vector, vector, real, vector)
+real pareto_type_2_cdf(row_vector, vector, real, row_vector)
+real pareto_type_2_cdf(row_vector, vector, real, real[])
+real pareto_type_2_cdf(row_vector, vector, vector, real)
+real pareto_type_2_cdf(row_vector, vector, vector, vector)
+real pareto_type_2_cdf(row_vector, vector, vector, row_vector)
+real pareto_type_2_cdf(row_vector, vector, vector, real[])
+real pareto_type_2_cdf(row_vector, vector, row_vector, real)
+real pareto_type_2_cdf(row_vector, vector, row_vector, vector)
+real pareto_type_2_cdf(row_vector, vector, row_vector, row_vector)
+real pareto_type_2_cdf(row_vector, vector, row_vector, real[])
+real pareto_type_2_cdf(row_vector, vector, real[], real)
+real pareto_type_2_cdf(row_vector, vector, real[], vector)
+real pareto_type_2_cdf(row_vector, vector, real[], row_vector)
+real pareto_type_2_cdf(row_vector, vector, real[], real[])
+real pareto_type_2_cdf(row_vector, row_vector, real, real)
+real pareto_type_2_cdf(row_vector, row_vector, real, vector)
+real pareto_type_2_cdf(row_vector, row_vector, real, row_vector)
+real pareto_type_2_cdf(row_vector, row_vector, real, real[])
+real pareto_type_2_cdf(row_vector, row_vector, vector, real)
+real pareto_type_2_cdf(row_vector, row_vector, vector, vector)
+real pareto_type_2_cdf(row_vector, row_vector, vector, row_vector)
+real pareto_type_2_cdf(row_vector, row_vector, vector, real[])
+real pareto_type_2_cdf(row_vector, row_vector, row_vector, real)
+real pareto_type_2_cdf(row_vector, row_vector, row_vector, vector)
+real pareto_type_2_cdf(row_vector, row_vector, row_vector, row_vector)
+real pareto_type_2_cdf(row_vector, row_vector, row_vector, real[])
+real pareto_type_2_cdf(row_vector, row_vector, real[], real)
+real pareto_type_2_cdf(row_vector, row_vector, real[], vector)
+real pareto_type_2_cdf(row_vector, row_vector, real[], row_vector)
+real pareto_type_2_cdf(row_vector, row_vector, real[], real[])
+real pareto_type_2_cdf(row_vector, real[], real, real)
+real pareto_type_2_cdf(row_vector, real[], real, vector)
+real pareto_type_2_cdf(row_vector, real[], real, row_vector)
+real pareto_type_2_cdf(row_vector, real[], real, real[])
+real pareto_type_2_cdf(row_vector, real[], vector, real)
+real pareto_type_2_cdf(row_vector, real[], vector, vector)
+real pareto_type_2_cdf(row_vector, real[], vector, row_vector)
+real pareto_type_2_cdf(row_vector, real[], vector, real[])
+real pareto_type_2_cdf(row_vector, real[], row_vector, real)
+real pareto_type_2_cdf(row_vector, real[], row_vector, vector)
+real pareto_type_2_cdf(row_vector, real[], row_vector, row_vector)
+real pareto_type_2_cdf(row_vector, real[], row_vector, real[])
+real pareto_type_2_cdf(row_vector, real[], real[], real)
+real pareto_type_2_cdf(row_vector, real[], real[], vector)
+real pareto_type_2_cdf(row_vector, real[], real[], row_vector)
+real pareto_type_2_cdf(row_vector, real[], real[], real[])
+real pareto_type_2_cdf(real[], real, real, vector)
+real pareto_type_2_cdf(real[], real, real, row_vector)
+real pareto_type_2_cdf(real[], real, vector, real)
+real pareto_type_2_cdf(real[], real, vector, vector)
+real pareto_type_2_cdf(real[], real, vector, row_vector)
+real pareto_type_2_cdf(real[], real, vector, real[])
+real pareto_type_2_cdf(real[], real, row_vector, real)
+real pareto_type_2_cdf(real[], real, row_vector, vector)
+real pareto_type_2_cdf(real[], real, row_vector, row_vector)
+real pareto_type_2_cdf(real[], real, row_vector, real[])
+real pareto_type_2_cdf(real[], real, real[], vector)
+real pareto_type_2_cdf(real[], real, real[], row_vector)
+real pareto_type_2_cdf(real[], vector, real, real)
+real pareto_type_2_cdf(real[], vector, real, vector)
+real pareto_type_2_cdf(real[], vector, real, row_vector)
+real pareto_type_2_cdf(real[], vector, real, real[])
+real pareto_type_2_cdf(real[], vector, vector, real)
+real pareto_type_2_cdf(real[], vector, vector, vector)
+real pareto_type_2_cdf(real[], vector, vector, row_vector)
+real pareto_type_2_cdf(real[], vector, vector, real[])
+real pareto_type_2_cdf(real[], vector, row_vector, real)
+real pareto_type_2_cdf(real[], vector, row_vector, vector)
+real pareto_type_2_cdf(real[], vector, row_vector, row_vector)
+real pareto_type_2_cdf(real[], vector, row_vector, real[])
+real pareto_type_2_cdf(real[], vector, real[], real)
+real pareto_type_2_cdf(real[], vector, real[], vector)
+real pareto_type_2_cdf(real[], vector, real[], row_vector)
+real pareto_type_2_cdf(real[], vector, real[], real[])
+real pareto_type_2_cdf(real[], row_vector, real, real)
+real pareto_type_2_cdf(real[], row_vector, real, vector)
+real pareto_type_2_cdf(real[], row_vector, real, row_vector)
+real pareto_type_2_cdf(real[], row_vector, real, real[])
+real pareto_type_2_cdf(real[], row_vector, vector, real)
+real pareto_type_2_cdf(real[], row_vector, vector, vector)
+real pareto_type_2_cdf(real[], row_vector, vector, row_vector)
+real pareto_type_2_cdf(real[], row_vector, vector, real[])
+real pareto_type_2_cdf(real[], row_vector, row_vector, real)
+real pareto_type_2_cdf(real[], row_vector, row_vector, vector)
+real pareto_type_2_cdf(real[], row_vector, row_vector, row_vector)
+real pareto_type_2_cdf(real[], row_vector, row_vector, real[])
+real pareto_type_2_cdf(real[], row_vector, real[], real)
+real pareto_type_2_cdf(real[], row_vector, real[], vector)
+real pareto_type_2_cdf(real[], row_vector, real[], row_vector)
+real pareto_type_2_cdf(real[], row_vector, real[], real[])
+real pareto_type_2_cdf(real[], real[], real, vector)
+real pareto_type_2_cdf(real[], real[], real, row_vector)
+real pareto_type_2_cdf(real[], real[], vector, real)
+real pareto_type_2_cdf(real[], real[], vector, vector)
+real pareto_type_2_cdf(real[], real[], vector, row_vector)
+real pareto_type_2_cdf(real[], real[], vector, real[])
+real pareto_type_2_cdf(real[], real[], row_vector, real)
+real pareto_type_2_cdf(real[], real[], row_vector, vector)
+real pareto_type_2_cdf(real[], real[], row_vector, row_vector)
+real pareto_type_2_cdf(real[], real[], row_vector, real[])
+real pareto_type_2_cdf(real[], real[], real[], vector)
+real pareto_type_2_cdf(real[], real[], real[], row_vector)
+real pareto_type_2_cdf_log(real, real, real, vector)
+real pareto_type_2_cdf_log(real, real, real, row_vector)
+real pareto_type_2_cdf_log(real, real, vector, real)
+real pareto_type_2_cdf_log(real, real, vector, vector)
+real pareto_type_2_cdf_log(real, real, vector, row_vector)
+real pareto_type_2_cdf_log(real, real, vector, real[])
+real pareto_type_2_cdf_log(real, real, row_vector, real)
+real pareto_type_2_cdf_log(real, real, row_vector, vector)
+real pareto_type_2_cdf_log(real, real, row_vector, row_vector)
+real pareto_type_2_cdf_log(real, real, row_vector, real[])
+real pareto_type_2_cdf_log(real, real, real[], vector)
+real pareto_type_2_cdf_log(real, real, real[], row_vector)
+real pareto_type_2_cdf_log(real, vector, real, real)
+real pareto_type_2_cdf_log(real, vector, real, vector)
+real pareto_type_2_cdf_log(real, vector, real, row_vector)
+real pareto_type_2_cdf_log(real, vector, real, real[])
+real pareto_type_2_cdf_log(real, vector, vector, real)
+real pareto_type_2_cdf_log(real, vector, vector, vector)
+real pareto_type_2_cdf_log(real, vector, vector, row_vector)
+real pareto_type_2_cdf_log(real, vector, vector, real[])
+real pareto_type_2_cdf_log(real, vector, row_vector, real)
+real pareto_type_2_cdf_log(real, vector, row_vector, vector)
+real pareto_type_2_cdf_log(real, vector, row_vector, row_vector)
+real pareto_type_2_cdf_log(real, vector, row_vector, real[])
+real pareto_type_2_cdf_log(real, vector, real[], real)
+real pareto_type_2_cdf_log(real, vector, real[], vector)
+real pareto_type_2_cdf_log(real, vector, real[], row_vector)
+real pareto_type_2_cdf_log(real, vector, real[], real[])
+real pareto_type_2_cdf_log(real, row_vector, real, real)
+real pareto_type_2_cdf_log(real, row_vector, real, vector)
+real pareto_type_2_cdf_log(real, row_vector, real, row_vector)
+real pareto_type_2_cdf_log(real, row_vector, real, real[])
+real pareto_type_2_cdf_log(real, row_vector, vector, real)
+real pareto_type_2_cdf_log(real, row_vector, vector, vector)
+real pareto_type_2_cdf_log(real, row_vector, vector, row_vector)
+real pareto_type_2_cdf_log(real, row_vector, vector, real[])
+real pareto_type_2_cdf_log(real, row_vector, row_vector, real)
+real pareto_type_2_cdf_log(real, row_vector, row_vector, vector)
+real pareto_type_2_cdf_log(real, row_vector, row_vector, row_vector)
+real pareto_type_2_cdf_log(real, row_vector, row_vector, real[])
+real pareto_type_2_cdf_log(real, row_vector, real[], real)
+real pareto_type_2_cdf_log(real, row_vector, real[], vector)
+real pareto_type_2_cdf_log(real, row_vector, real[], row_vector)
+real pareto_type_2_cdf_log(real, row_vector, real[], real[])
+real pareto_type_2_cdf_log(real, real[], real, vector)
+real pareto_type_2_cdf_log(real, real[], real, row_vector)
+real pareto_type_2_cdf_log(real, real[], vector, real)
+real pareto_type_2_cdf_log(real, real[], vector, vector)
+real pareto_type_2_cdf_log(real, real[], vector, row_vector)
+real pareto_type_2_cdf_log(real, real[], vector, real[])
+real pareto_type_2_cdf_log(real, real[], row_vector, real)
+real pareto_type_2_cdf_log(real, real[], row_vector, vector)
+real pareto_type_2_cdf_log(real, real[], row_vector, row_vector)
+real pareto_type_2_cdf_log(real, real[], row_vector, real[])
+real pareto_type_2_cdf_log(real, real[], real[], vector)
+real pareto_type_2_cdf_log(real, real[], real[], row_vector)
+real pareto_type_2_cdf_log(vector, real, real, real)
+real pareto_type_2_cdf_log(vector, real, real, vector)
+real pareto_type_2_cdf_log(vector, real, real, row_vector)
+real pareto_type_2_cdf_log(vector, real, real, real[])
+real pareto_type_2_cdf_log(vector, real, vector, real)
+real pareto_type_2_cdf_log(vector, real, vector, vector)
+real pareto_type_2_cdf_log(vector, real, vector, row_vector)
+real pareto_type_2_cdf_log(vector, real, vector, real[])
+real pareto_type_2_cdf_log(vector, real, row_vector, real)
+real pareto_type_2_cdf_log(vector, real, row_vector, vector)
+real pareto_type_2_cdf_log(vector, real, row_vector, row_vector)
+real pareto_type_2_cdf_log(vector, real, row_vector, real[])
+real pareto_type_2_cdf_log(vector, real, real[], real)
+real pareto_type_2_cdf_log(vector, real, real[], vector)
+real pareto_type_2_cdf_log(vector, real, real[], row_vector)
+real pareto_type_2_cdf_log(vector, real, real[], real[])
+real pareto_type_2_cdf_log(vector, vector, real, real)
+real pareto_type_2_cdf_log(vector, vector, real, vector)
+real pareto_type_2_cdf_log(vector, vector, real, row_vector)
+real pareto_type_2_cdf_log(vector, vector, real, real[])
+real pareto_type_2_cdf_log(vector, vector, vector, real)
+real pareto_type_2_cdf_log(vector, vector, vector, vector)
+real pareto_type_2_cdf_log(vector, vector, vector, row_vector)
+real pareto_type_2_cdf_log(vector, vector, vector, real[])
+real pareto_type_2_cdf_log(vector, vector, row_vector, real)
+real pareto_type_2_cdf_log(vector, vector, row_vector, vector)
+real pareto_type_2_cdf_log(vector, vector, row_vector, row_vector)
+real pareto_type_2_cdf_log(vector, vector, row_vector, real[])
+real pareto_type_2_cdf_log(vector, vector, real[], real)
+real pareto_type_2_cdf_log(vector, vector, real[], vector)
+real pareto_type_2_cdf_log(vector, vector, real[], row_vector)
+real pareto_type_2_cdf_log(vector, vector, real[], real[])
+real pareto_type_2_cdf_log(vector, row_vector, real, real)
+real pareto_type_2_cdf_log(vector, row_vector, real, vector)
+real pareto_type_2_cdf_log(vector, row_vector, real, row_vector)
+real pareto_type_2_cdf_log(vector, row_vector, real, real[])
+real pareto_type_2_cdf_log(vector, row_vector, vector, real)
+real pareto_type_2_cdf_log(vector, row_vector, vector, vector)
+real pareto_type_2_cdf_log(vector, row_vector, vector, row_vector)
+real pareto_type_2_cdf_log(vector, row_vector, vector, real[])
+real pareto_type_2_cdf_log(vector, row_vector, row_vector, real)
+real pareto_type_2_cdf_log(vector, row_vector, row_vector, vector)
+real pareto_type_2_cdf_log(vector, row_vector, row_vector, row_vector)
+real pareto_type_2_cdf_log(vector, row_vector, row_vector, real[])
+real pareto_type_2_cdf_log(vector, row_vector, real[], real)
+real pareto_type_2_cdf_log(vector, row_vector, real[], vector)
+real pareto_type_2_cdf_log(vector, row_vector, real[], row_vector)
+real pareto_type_2_cdf_log(vector, row_vector, real[], real[])
+real pareto_type_2_cdf_log(vector, real[], real, real)
+real pareto_type_2_cdf_log(vector, real[], real, vector)
+real pareto_type_2_cdf_log(vector, real[], real, row_vector)
+real pareto_type_2_cdf_log(vector, real[], real, real[])
+real pareto_type_2_cdf_log(vector, real[], vector, real)
+real pareto_type_2_cdf_log(vector, real[], vector, vector)
+real pareto_type_2_cdf_log(vector, real[], vector, row_vector)
+real pareto_type_2_cdf_log(vector, real[], vector, real[])
+real pareto_type_2_cdf_log(vector, real[], row_vector, real)
+real pareto_type_2_cdf_log(vector, real[], row_vector, vector)
+real pareto_type_2_cdf_log(vector, real[], row_vector, row_vector)
+real pareto_type_2_cdf_log(vector, real[], row_vector, real[])
+real pareto_type_2_cdf_log(vector, real[], real[], real)
+real pareto_type_2_cdf_log(vector, real[], real[], vector)
+real pareto_type_2_cdf_log(vector, real[], real[], row_vector)
+real pareto_type_2_cdf_log(vector, real[], real[], real[])
+real pareto_type_2_cdf_log(row_vector, real, real, real)
+real pareto_type_2_cdf_log(row_vector, real, real, vector)
+real pareto_type_2_cdf_log(row_vector, real, real, row_vector)
+real pareto_type_2_cdf_log(row_vector, real, real, real[])
+real pareto_type_2_cdf_log(row_vector, real, vector, real)
+real pareto_type_2_cdf_log(row_vector, real, vector, vector)
+real pareto_type_2_cdf_log(row_vector, real, vector, row_vector)
+real pareto_type_2_cdf_log(row_vector, real, vector, real[])
+real pareto_type_2_cdf_log(row_vector, real, row_vector, real)
+real pareto_type_2_cdf_log(row_vector, real, row_vector, vector)
+real pareto_type_2_cdf_log(row_vector, real, row_vector, row_vector)
+real pareto_type_2_cdf_log(row_vector, real, row_vector, real[])
+real pareto_type_2_cdf_log(row_vector, real, real[], real)
+real pareto_type_2_cdf_log(row_vector, real, real[], vector)
+real pareto_type_2_cdf_log(row_vector, real, real[], row_vector)
+real pareto_type_2_cdf_log(row_vector, real, real[], real[])
+real pareto_type_2_cdf_log(row_vector, vector, real, real)
+real pareto_type_2_cdf_log(row_vector, vector, real, vector)
+real pareto_type_2_cdf_log(row_vector, vector, real, row_vector)
+real pareto_type_2_cdf_log(row_vector, vector, real, real[])
+real pareto_type_2_cdf_log(row_vector, vector, vector, real)
+real pareto_type_2_cdf_log(row_vector, vector, vector, vector)
+real pareto_type_2_cdf_log(row_vector, vector, vector, row_vector)
+real pareto_type_2_cdf_log(row_vector, vector, vector, real[])
+real pareto_type_2_cdf_log(row_vector, vector, row_vector, real)
+real pareto_type_2_cdf_log(row_vector, vector, row_vector, vector)
+real pareto_type_2_cdf_log(row_vector, vector, row_vector, row_vector)
+real pareto_type_2_cdf_log(row_vector, vector, row_vector, real[])
+real pareto_type_2_cdf_log(row_vector, vector, real[], real)
+real pareto_type_2_cdf_log(row_vector, vector, real[], vector)
+real pareto_type_2_cdf_log(row_vector, vector, real[], row_vector)
+real pareto_type_2_cdf_log(row_vector, vector, real[], real[])
+real pareto_type_2_cdf_log(row_vector, row_vector, real, real)
+real pareto_type_2_cdf_log(row_vector, row_vector, real, vector)
+real pareto_type_2_cdf_log(row_vector, row_vector, real, row_vector)
+real pareto_type_2_cdf_log(row_vector, row_vector, real, real[])
+real pareto_type_2_cdf_log(row_vector, row_vector, vector, real)
+real pareto_type_2_cdf_log(row_vector, row_vector, vector, vector)
+real pareto_type_2_cdf_log(row_vector, row_vector, vector, row_vector)
+real pareto_type_2_cdf_log(row_vector, row_vector, vector, real[])
+real pareto_type_2_cdf_log(row_vector, row_vector, row_vector, real)
+real pareto_type_2_cdf_log(row_vector, row_vector, row_vector, vector)
+real pareto_type_2_cdf_log(row_vector, row_vector, row_vector, row_vector)
+real pareto_type_2_cdf_log(row_vector, row_vector, row_vector, real[])
+real pareto_type_2_cdf_log(row_vector, row_vector, real[], real)
+real pareto_type_2_cdf_log(row_vector, row_vector, real[], vector)
+real pareto_type_2_cdf_log(row_vector, row_vector, real[], row_vector)
+real pareto_type_2_cdf_log(row_vector, row_vector, real[], real[])
+real pareto_type_2_cdf_log(row_vector, real[], real, real)
+real pareto_type_2_cdf_log(row_vector, real[], real, vector)
+real pareto_type_2_cdf_log(row_vector, real[], real, row_vector)
+real pareto_type_2_cdf_log(row_vector, real[], real, real[])
+real pareto_type_2_cdf_log(row_vector, real[], vector, real)
+real pareto_type_2_cdf_log(row_vector, real[], vector, vector)
+real pareto_type_2_cdf_log(row_vector, real[], vector, row_vector)
+real pareto_type_2_cdf_log(row_vector, real[], vector, real[])
+real pareto_type_2_cdf_log(row_vector, real[], row_vector, real)
+real pareto_type_2_cdf_log(row_vector, real[], row_vector, vector)
+real pareto_type_2_cdf_log(row_vector, real[], row_vector, row_vector)
+real pareto_type_2_cdf_log(row_vector, real[], row_vector, real[])
+real pareto_type_2_cdf_log(row_vector, real[], real[], real)
+real pareto_type_2_cdf_log(row_vector, real[], real[], vector)
+real pareto_type_2_cdf_log(row_vector, real[], real[], row_vector)
+real pareto_type_2_cdf_log(row_vector, real[], real[], real[])
+real pareto_type_2_cdf_log(real[], real, real, vector)
+real pareto_type_2_cdf_log(real[], real, real, row_vector)
+real pareto_type_2_cdf_log(real[], real, vector, real)
+real pareto_type_2_cdf_log(real[], real, vector, vector)
+real pareto_type_2_cdf_log(real[], real, vector, row_vector)
+real pareto_type_2_cdf_log(real[], real, vector, real[])
+real pareto_type_2_cdf_log(real[], real, row_vector, real)
+real pareto_type_2_cdf_log(real[], real, row_vector, vector)
+real pareto_type_2_cdf_log(real[], real, row_vector, row_vector)
+real pareto_type_2_cdf_log(real[], real, row_vector, real[])
+real pareto_type_2_cdf_log(real[], real, real[], vector)
+real pareto_type_2_cdf_log(real[], real, real[], row_vector)
+real pareto_type_2_cdf_log(real[], vector, real, real)
+real pareto_type_2_cdf_log(real[], vector, real, vector)
+real pareto_type_2_cdf_log(real[], vector, real, row_vector)
+real pareto_type_2_cdf_log(real[], vector, real, real[])
+real pareto_type_2_cdf_log(real[], vector, vector, real)
+real pareto_type_2_cdf_log(real[], vector, vector, vector)
+real pareto_type_2_cdf_log(real[], vector, vector, row_vector)
+real pareto_type_2_cdf_log(real[], vector, vector, real[])
+real pareto_type_2_cdf_log(real[], vector, row_vector, real)
+real pareto_type_2_cdf_log(real[], vector, row_vector, vector)
+real pareto_type_2_cdf_log(real[], vector, row_vector, row_vector)
+real pareto_type_2_cdf_log(real[], vector, row_vector, real[])
+real pareto_type_2_cdf_log(real[], vector, real[], real)
+real pareto_type_2_cdf_log(real[], vector, real[], vector)
+real pareto_type_2_cdf_log(real[], vector, real[], row_vector)
+real pareto_type_2_cdf_log(real[], vector, real[], real[])
+real pareto_type_2_cdf_log(real[], row_vector, real, real)
+real pareto_type_2_cdf_log(real[], row_vector, real, vector)
+real pareto_type_2_cdf_log(real[], row_vector, real, row_vector)
+real pareto_type_2_cdf_log(real[], row_vector, real, real[])
+real pareto_type_2_cdf_log(real[], row_vector, vector, real)
+real pareto_type_2_cdf_log(real[], row_vector, vector, vector)
+real pareto_type_2_cdf_log(real[], row_vector, vector, row_vector)
+real pareto_type_2_cdf_log(real[], row_vector, vector, real[])
+real pareto_type_2_cdf_log(real[], row_vector, row_vector, real)
+real pareto_type_2_cdf_log(real[], row_vector, row_vector, vector)
+real pareto_type_2_cdf_log(real[], row_vector, row_vector, row_vector)
+real pareto_type_2_cdf_log(real[], row_vector, row_vector, real[])
+real pareto_type_2_cdf_log(real[], row_vector, real[], real)
+real pareto_type_2_cdf_log(real[], row_vector, real[], vector)
+real pareto_type_2_cdf_log(real[], row_vector, real[], row_vector)
+real pareto_type_2_cdf_log(real[], row_vector, real[], real[])
+real pareto_type_2_cdf_log(real[], real[], real, vector)
+real pareto_type_2_cdf_log(real[], real[], real, row_vector)
+real pareto_type_2_cdf_log(real[], real[], vector, real)
+real pareto_type_2_cdf_log(real[], real[], vector, vector)
+real pareto_type_2_cdf_log(real[], real[], vector, row_vector)
+real pareto_type_2_cdf_log(real[], real[], vector, real[])
+real pareto_type_2_cdf_log(real[], real[], row_vector, real)
+real pareto_type_2_cdf_log(real[], real[], row_vector, vector)
+real pareto_type_2_cdf_log(real[], real[], row_vector, row_vector)
+real pareto_type_2_cdf_log(real[], real[], row_vector, real[])
+real pareto_type_2_cdf_log(real[], real[], real[], vector)
+real pareto_type_2_cdf_log(real[], real[], real[], row_vector)
+real pareto_type_2_lccdf(real, real, real, vector)
+real pareto_type_2_lccdf(real, real, real, row_vector)
+real pareto_type_2_lccdf(real, real, vector, real)
+real pareto_type_2_lccdf(real, real, vector, vector)
+real pareto_type_2_lccdf(real, real, vector, row_vector)
+real pareto_type_2_lccdf(real, real, vector, real[])
+real pareto_type_2_lccdf(real, real, row_vector, real)
+real pareto_type_2_lccdf(real, real, row_vector, vector)
+real pareto_type_2_lccdf(real, real, row_vector, row_vector)
+real pareto_type_2_lccdf(real, real, row_vector, real[])
+real pareto_type_2_lccdf(real, real, real[], vector)
+real pareto_type_2_lccdf(real, real, real[], row_vector)
+real pareto_type_2_lccdf(real, vector, real, real)
+real pareto_type_2_lccdf(real, vector, real, vector)
+real pareto_type_2_lccdf(real, vector, real, row_vector)
+real pareto_type_2_lccdf(real, vector, real, real[])
+real pareto_type_2_lccdf(real, vector, vector, real)
+real pareto_type_2_lccdf(real, vector, vector, vector)
+real pareto_type_2_lccdf(real, vector, vector, row_vector)
+real pareto_type_2_lccdf(real, vector, vector, real[])
+real pareto_type_2_lccdf(real, vector, row_vector, real)
+real pareto_type_2_lccdf(real, vector, row_vector, vector)
+real pareto_type_2_lccdf(real, vector, row_vector, row_vector)
+real pareto_type_2_lccdf(real, vector, row_vector, real[])
+real pareto_type_2_lccdf(real, vector, real[], real)
+real pareto_type_2_lccdf(real, vector, real[], vector)
+real pareto_type_2_lccdf(real, vector, real[], row_vector)
+real pareto_type_2_lccdf(real, vector, real[], real[])
+real pareto_type_2_lccdf(real, row_vector, real, real)
+real pareto_type_2_lccdf(real, row_vector, real, vector)
+real pareto_type_2_lccdf(real, row_vector, real, row_vector)
+real pareto_type_2_lccdf(real, row_vector, real, real[])
+real pareto_type_2_lccdf(real, row_vector, vector, real)
+real pareto_type_2_lccdf(real, row_vector, vector, vector)
+real pareto_type_2_lccdf(real, row_vector, vector, row_vector)
+real pareto_type_2_lccdf(real, row_vector, vector, real[])
+real pareto_type_2_lccdf(real, row_vector, row_vector, real)
+real pareto_type_2_lccdf(real, row_vector, row_vector, vector)
+real pareto_type_2_lccdf(real, row_vector, row_vector, row_vector)
+real pareto_type_2_lccdf(real, row_vector, row_vector, real[])
+real pareto_type_2_lccdf(real, row_vector, real[], real)
+real pareto_type_2_lccdf(real, row_vector, real[], vector)
+real pareto_type_2_lccdf(real, row_vector, real[], row_vector)
+real pareto_type_2_lccdf(real, row_vector, real[], real[])
+real pareto_type_2_lccdf(real, real[], real, vector)
+real pareto_type_2_lccdf(real, real[], real, row_vector)
+real pareto_type_2_lccdf(real, real[], vector, real)
+real pareto_type_2_lccdf(real, real[], vector, vector)
+real pareto_type_2_lccdf(real, real[], vector, row_vector)
+real pareto_type_2_lccdf(real, real[], vector, real[])
+real pareto_type_2_lccdf(real, real[], row_vector, real)
+real pareto_type_2_lccdf(real, real[], row_vector, vector)
+real pareto_type_2_lccdf(real, real[], row_vector, row_vector)
+real pareto_type_2_lccdf(real, real[], row_vector, real[])
+real pareto_type_2_lccdf(real, real[], real[], vector)
+real pareto_type_2_lccdf(real, real[], real[], row_vector)
+real pareto_type_2_lccdf(vector, real, real, real)
+real pareto_type_2_lccdf(vector, real, real, vector)
+real pareto_type_2_lccdf(vector, real, real, row_vector)
+real pareto_type_2_lccdf(vector, real, real, real[])
+real pareto_type_2_lccdf(vector, real, vector, real)
+real pareto_type_2_lccdf(vector, real, vector, vector)
+real pareto_type_2_lccdf(vector, real, vector, row_vector)
+real pareto_type_2_lccdf(vector, real, vector, real[])
+real pareto_type_2_lccdf(vector, real, row_vector, real)
+real pareto_type_2_lccdf(vector, real, row_vector, vector)
+real pareto_type_2_lccdf(vector, real, row_vector, row_vector)
+real pareto_type_2_lccdf(vector, real, row_vector, real[])
+real pareto_type_2_lccdf(vector, real, real[], real)
+real pareto_type_2_lccdf(vector, real, real[], vector)
+real pareto_type_2_lccdf(vector, real, real[], row_vector)
+real pareto_type_2_lccdf(vector, real, real[], real[])
+real pareto_type_2_lccdf(vector, vector, real, real)
+real pareto_type_2_lccdf(vector, vector, real, vector)
+real pareto_type_2_lccdf(vector, vector, real, row_vector)
+real pareto_type_2_lccdf(vector, vector, real, real[])
+real pareto_type_2_lccdf(vector, vector, vector, real)
+real pareto_type_2_lccdf(vector, vector, vector, vector)
+real pareto_type_2_lccdf(vector, vector, vector, row_vector)
+real pareto_type_2_lccdf(vector, vector, vector, real[])
+real pareto_type_2_lccdf(vector, vector, row_vector, real)
+real pareto_type_2_lccdf(vector, vector, row_vector, vector)
+real pareto_type_2_lccdf(vector, vector, row_vector, row_vector)
+real pareto_type_2_lccdf(vector, vector, row_vector, real[])
+real pareto_type_2_lccdf(vector, vector, real[], real)
+real pareto_type_2_lccdf(vector, vector, real[], vector)
+real pareto_type_2_lccdf(vector, vector, real[], row_vector)
+real pareto_type_2_lccdf(vector, vector, real[], real[])
+real pareto_type_2_lccdf(vector, row_vector, real, real)
+real pareto_type_2_lccdf(vector, row_vector, real, vector)
+real pareto_type_2_lccdf(vector, row_vector, real, row_vector)
+real pareto_type_2_lccdf(vector, row_vector, real, real[])
+real pareto_type_2_lccdf(vector, row_vector, vector, real)
+real pareto_type_2_lccdf(vector, row_vector, vector, vector)
+real pareto_type_2_lccdf(vector, row_vector, vector, row_vector)
+real pareto_type_2_lccdf(vector, row_vector, vector, real[])
+real pareto_type_2_lccdf(vector, row_vector, row_vector, real)
+real pareto_type_2_lccdf(vector, row_vector, row_vector, vector)
+real pareto_type_2_lccdf(vector, row_vector, row_vector, row_vector)
+real pareto_type_2_lccdf(vector, row_vector, row_vector, real[])
+real pareto_type_2_lccdf(vector, row_vector, real[], real)
+real pareto_type_2_lccdf(vector, row_vector, real[], vector)
+real pareto_type_2_lccdf(vector, row_vector, real[], row_vector)
+real pareto_type_2_lccdf(vector, row_vector, real[], real[])
+real pareto_type_2_lccdf(vector, real[], real, real)
+real pareto_type_2_lccdf(vector, real[], real, vector)
+real pareto_type_2_lccdf(vector, real[], real, row_vector)
+real pareto_type_2_lccdf(vector, real[], real, real[])
+real pareto_type_2_lccdf(vector, real[], vector, real)
+real pareto_type_2_lccdf(vector, real[], vector, vector)
+real pareto_type_2_lccdf(vector, real[], vector, row_vector)
+real pareto_type_2_lccdf(vector, real[], vector, real[])
+real pareto_type_2_lccdf(vector, real[], row_vector, real)
+real pareto_type_2_lccdf(vector, real[], row_vector, vector)
+real pareto_type_2_lccdf(vector, real[], row_vector, row_vector)
+real pareto_type_2_lccdf(vector, real[], row_vector, real[])
+real pareto_type_2_lccdf(vector, real[], real[], real)
+real pareto_type_2_lccdf(vector, real[], real[], vector)
+real pareto_type_2_lccdf(vector, real[], real[], row_vector)
+real pareto_type_2_lccdf(vector, real[], real[], real[])
+real pareto_type_2_lccdf(row_vector, real, real, real)
+real pareto_type_2_lccdf(row_vector, real, real, vector)
+real pareto_type_2_lccdf(row_vector, real, real, row_vector)
+real pareto_type_2_lccdf(row_vector, real, real, real[])
+real pareto_type_2_lccdf(row_vector, real, vector, real)
+real pareto_type_2_lccdf(row_vector, real, vector, vector)
+real pareto_type_2_lccdf(row_vector, real, vector, row_vector)
+real pareto_type_2_lccdf(row_vector, real, vector, real[])
+real pareto_type_2_lccdf(row_vector, real, row_vector, real)
+real pareto_type_2_lccdf(row_vector, real, row_vector, vector)
+real pareto_type_2_lccdf(row_vector, real, row_vector, row_vector)
+real pareto_type_2_lccdf(row_vector, real, row_vector, real[])
+real pareto_type_2_lccdf(row_vector, real, real[], real)
+real pareto_type_2_lccdf(row_vector, real, real[], vector)
+real pareto_type_2_lccdf(row_vector, real, real[], row_vector)
+real pareto_type_2_lccdf(row_vector, real, real[], real[])
+real pareto_type_2_lccdf(row_vector, vector, real, real)
+real pareto_type_2_lccdf(row_vector, vector, real, vector)
+real pareto_type_2_lccdf(row_vector, vector, real, row_vector)
+real pareto_type_2_lccdf(row_vector, vector, real, real[])
+real pareto_type_2_lccdf(row_vector, vector, vector, real)
+real pareto_type_2_lccdf(row_vector, vector, vector, vector)
+real pareto_type_2_lccdf(row_vector, vector, vector, row_vector)
+real pareto_type_2_lccdf(row_vector, vector, vector, real[])
+real pareto_type_2_lccdf(row_vector, vector, row_vector, real)
+real pareto_type_2_lccdf(row_vector, vector, row_vector, vector)
+real pareto_type_2_lccdf(row_vector, vector, row_vector, row_vector)
+real pareto_type_2_lccdf(row_vector, vector, row_vector, real[])
+real pareto_type_2_lccdf(row_vector, vector, real[], real)
+real pareto_type_2_lccdf(row_vector, vector, real[], vector)
+real pareto_type_2_lccdf(row_vector, vector, real[], row_vector)
+real pareto_type_2_lccdf(row_vector, vector, real[], real[])
+real pareto_type_2_lccdf(row_vector, row_vector, real, real)
+real pareto_type_2_lccdf(row_vector, row_vector, real, vector)
+real pareto_type_2_lccdf(row_vector, row_vector, real, row_vector)
+real pareto_type_2_lccdf(row_vector, row_vector, real, real[])
+real pareto_type_2_lccdf(row_vector, row_vector, vector, real)
+real pareto_type_2_lccdf(row_vector, row_vector, vector, vector)
+real pareto_type_2_lccdf(row_vector, row_vector, vector, row_vector)
+real pareto_type_2_lccdf(row_vector, row_vector, vector, real[])
+real pareto_type_2_lccdf(row_vector, row_vector, row_vector, real)
+real pareto_type_2_lccdf(row_vector, row_vector, row_vector, vector)
+real pareto_type_2_lccdf(row_vector, row_vector, row_vector, row_vector)
+real pareto_type_2_lccdf(row_vector, row_vector, row_vector, real[])
+real pareto_type_2_lccdf(row_vector, row_vector, real[], real)
+real pareto_type_2_lccdf(row_vector, row_vector, real[], vector)
+real pareto_type_2_lccdf(row_vector, row_vector, real[], row_vector)
+real pareto_type_2_lccdf(row_vector, row_vector, real[], real[])
+real pareto_type_2_lccdf(row_vector, real[], real, real)
+real pareto_type_2_lccdf(row_vector, real[], real, vector)
+real pareto_type_2_lccdf(row_vector, real[], real, row_vector)
+real pareto_type_2_lccdf(row_vector, real[], real, real[])
+real pareto_type_2_lccdf(row_vector, real[], vector, real)
+real pareto_type_2_lccdf(row_vector, real[], vector, vector)
+real pareto_type_2_lccdf(row_vector, real[], vector, row_vector)
+real pareto_type_2_lccdf(row_vector, real[], vector, real[])
+real pareto_type_2_lccdf(row_vector, real[], row_vector, real)
+real pareto_type_2_lccdf(row_vector, real[], row_vector, vector)
+real pareto_type_2_lccdf(row_vector, real[], row_vector, row_vector)
+real pareto_type_2_lccdf(row_vector, real[], row_vector, real[])
+real pareto_type_2_lccdf(row_vector, real[], real[], real)
+real pareto_type_2_lccdf(row_vector, real[], real[], vector)
+real pareto_type_2_lccdf(row_vector, real[], real[], row_vector)
+real pareto_type_2_lccdf(row_vector, real[], real[], real[])
+real pareto_type_2_lccdf(real[], real, real, vector)
+real pareto_type_2_lccdf(real[], real, real, row_vector)
+real pareto_type_2_lccdf(real[], real, vector, real)
+real pareto_type_2_lccdf(real[], real, vector, vector)
+real pareto_type_2_lccdf(real[], real, vector, row_vector)
+real pareto_type_2_lccdf(real[], real, vector, real[])
+real pareto_type_2_lccdf(real[], real, row_vector, real)
+real pareto_type_2_lccdf(real[], real, row_vector, vector)
+real pareto_type_2_lccdf(real[], real, row_vector, row_vector)
+real pareto_type_2_lccdf(real[], real, row_vector, real[])
+real pareto_type_2_lccdf(real[], real, real[], vector)
+real pareto_type_2_lccdf(real[], real, real[], row_vector)
+real pareto_type_2_lccdf(real[], vector, real, real)
+real pareto_type_2_lccdf(real[], vector, real, vector)
+real pareto_type_2_lccdf(real[], vector, real, row_vector)
+real pareto_type_2_lccdf(real[], vector, real, real[])
+real pareto_type_2_lccdf(real[], vector, vector, real)
+real pareto_type_2_lccdf(real[], vector, vector, vector)
+real pareto_type_2_lccdf(real[], vector, vector, row_vector)
+real pareto_type_2_lccdf(real[], vector, vector, real[])
+real pareto_type_2_lccdf(real[], vector, row_vector, real)
+real pareto_type_2_lccdf(real[], vector, row_vector, vector)
+real pareto_type_2_lccdf(real[], vector, row_vector, row_vector)
+real pareto_type_2_lccdf(real[], vector, row_vector, real[])
+real pareto_type_2_lccdf(real[], vector, real[], real)
+real pareto_type_2_lccdf(real[], vector, real[], vector)
+real pareto_type_2_lccdf(real[], vector, real[], row_vector)
+real pareto_type_2_lccdf(real[], vector, real[], real[])
+real pareto_type_2_lccdf(real[], row_vector, real, real)
+real pareto_type_2_lccdf(real[], row_vector, real, vector)
+real pareto_type_2_lccdf(real[], row_vector, real, row_vector)
+real pareto_type_2_lccdf(real[], row_vector, real, real[])
+real pareto_type_2_lccdf(real[], row_vector, vector, real)
+real pareto_type_2_lccdf(real[], row_vector, vector, vector)
+real pareto_type_2_lccdf(real[], row_vector, vector, row_vector)
+real pareto_type_2_lccdf(real[], row_vector, vector, real[])
+real pareto_type_2_lccdf(real[], row_vector, row_vector, real)
+real pareto_type_2_lccdf(real[], row_vector, row_vector, vector)
+real pareto_type_2_lccdf(real[], row_vector, row_vector, row_vector)
+real pareto_type_2_lccdf(real[], row_vector, row_vector, real[])
+real pareto_type_2_lccdf(real[], row_vector, real[], real)
+real pareto_type_2_lccdf(real[], row_vector, real[], vector)
+real pareto_type_2_lccdf(real[], row_vector, real[], row_vector)
+real pareto_type_2_lccdf(real[], row_vector, real[], real[])
+real pareto_type_2_lccdf(real[], real[], real, vector)
+real pareto_type_2_lccdf(real[], real[], real, row_vector)
+real pareto_type_2_lccdf(real[], real[], vector, real)
+real pareto_type_2_lccdf(real[], real[], vector, vector)
+real pareto_type_2_lccdf(real[], real[], vector, row_vector)
+real pareto_type_2_lccdf(real[], real[], vector, real[])
+real pareto_type_2_lccdf(real[], real[], row_vector, real)
+real pareto_type_2_lccdf(real[], real[], row_vector, vector)
+real pareto_type_2_lccdf(real[], real[], row_vector, row_vector)
+real pareto_type_2_lccdf(real[], real[], row_vector, real[])
+real pareto_type_2_lccdf(real[], real[], real[], vector)
+real pareto_type_2_lccdf(real[], real[], real[], row_vector)
+real pareto_type_2_lcdf(real, real, real, vector)
+real pareto_type_2_lcdf(real, real, real, row_vector)
+real pareto_type_2_lcdf(real, real, vector, real)
+real pareto_type_2_lcdf(real, real, vector, vector)
+real pareto_type_2_lcdf(real, real, vector, row_vector)
+real pareto_type_2_lcdf(real, real, vector, real[])
+real pareto_type_2_lcdf(real, real, row_vector, real)
+real pareto_type_2_lcdf(real, real, row_vector, vector)
+real pareto_type_2_lcdf(real, real, row_vector, row_vector)
+real pareto_type_2_lcdf(real, real, row_vector, real[])
+real pareto_type_2_lcdf(real, real, real[], vector)
+real pareto_type_2_lcdf(real, real, real[], row_vector)
+real pareto_type_2_lcdf(real, vector, real, real)
+real pareto_type_2_lcdf(real, vector, real, vector)
+real pareto_type_2_lcdf(real, vector, real, row_vector)
+real pareto_type_2_lcdf(real, vector, real, real[])
+real pareto_type_2_lcdf(real, vector, vector, real)
+real pareto_type_2_lcdf(real, vector, vector, vector)
+real pareto_type_2_lcdf(real, vector, vector, row_vector)
+real pareto_type_2_lcdf(real, vector, vector, real[])
+real pareto_type_2_lcdf(real, vector, row_vector, real)
+real pareto_type_2_lcdf(real, vector, row_vector, vector)
+real pareto_type_2_lcdf(real, vector, row_vector, row_vector)
+real pareto_type_2_lcdf(real, vector, row_vector, real[])
+real pareto_type_2_lcdf(real, vector, real[], real)
+real pareto_type_2_lcdf(real, vector, real[], vector)
+real pareto_type_2_lcdf(real, vector, real[], row_vector)
+real pareto_type_2_lcdf(real, vector, real[], real[])
+real pareto_type_2_lcdf(real, row_vector, real, real)
+real pareto_type_2_lcdf(real, row_vector, real, vector)
+real pareto_type_2_lcdf(real, row_vector, real, row_vector)
+real pareto_type_2_lcdf(real, row_vector, real, real[])
+real pareto_type_2_lcdf(real, row_vector, vector, real)
+real pareto_type_2_lcdf(real, row_vector, vector, vector)
+real pareto_type_2_lcdf(real, row_vector, vector, row_vector)
+real pareto_type_2_lcdf(real, row_vector, vector, real[])
+real pareto_type_2_lcdf(real, row_vector, row_vector, real)
+real pareto_type_2_lcdf(real, row_vector, row_vector, vector)
+real pareto_type_2_lcdf(real, row_vector, row_vector, row_vector)
+real pareto_type_2_lcdf(real, row_vector, row_vector, real[])
+real pareto_type_2_lcdf(real, row_vector, real[], real)
+real pareto_type_2_lcdf(real, row_vector, real[], vector)
+real pareto_type_2_lcdf(real, row_vector, real[], row_vector)
+real pareto_type_2_lcdf(real, row_vector, real[], real[])
+real pareto_type_2_lcdf(real, real[], real, vector)
+real pareto_type_2_lcdf(real, real[], real, row_vector)
+real pareto_type_2_lcdf(real, real[], vector, real)
+real pareto_type_2_lcdf(real, real[], vector, vector)
+real pareto_type_2_lcdf(real, real[], vector, row_vector)
+real pareto_type_2_lcdf(real, real[], vector, real[])
+real pareto_type_2_lcdf(real, real[], row_vector, real)
+real pareto_type_2_lcdf(real, real[], row_vector, vector)
+real pareto_type_2_lcdf(real, real[], row_vector, row_vector)
+real pareto_type_2_lcdf(real, real[], row_vector, real[])
+real pareto_type_2_lcdf(real, real[], real[], vector)
+real pareto_type_2_lcdf(real, real[], real[], row_vector)
+real pareto_type_2_lcdf(vector, real, real, real)
+real pareto_type_2_lcdf(vector, real, real, vector)
+real pareto_type_2_lcdf(vector, real, real, row_vector)
+real pareto_type_2_lcdf(vector, real, real, real[])
+real pareto_type_2_lcdf(vector, real, vector, real)
+real pareto_type_2_lcdf(vector, real, vector, vector)
+real pareto_type_2_lcdf(vector, real, vector, row_vector)
+real pareto_type_2_lcdf(vector, real, vector, real[])
+real pareto_type_2_lcdf(vector, real, row_vector, real)
+real pareto_type_2_lcdf(vector, real, row_vector, vector)
+real pareto_type_2_lcdf(vector, real, row_vector, row_vector)
+real pareto_type_2_lcdf(vector, real, row_vector, real[])
+real pareto_type_2_lcdf(vector, real, real[], real)
+real pareto_type_2_lcdf(vector, real, real[], vector)
+real pareto_type_2_lcdf(vector, real, real[], row_vector)
+real pareto_type_2_lcdf(vector, real, real[], real[])
+real pareto_type_2_lcdf(vector, vector, real, real)
+real pareto_type_2_lcdf(vector, vector, real, vector)
+real pareto_type_2_lcdf(vector, vector, real, row_vector)
+real pareto_type_2_lcdf(vector, vector, real, real[])
+real pareto_type_2_lcdf(vector, vector, vector, real)
+real pareto_type_2_lcdf(vector, vector, vector, vector)
+real pareto_type_2_lcdf(vector, vector, vector, row_vector)
+real pareto_type_2_lcdf(vector, vector, vector, real[])
+real pareto_type_2_lcdf(vector, vector, row_vector, real)
+real pareto_type_2_lcdf(vector, vector, row_vector, vector)
+real pareto_type_2_lcdf(vector, vector, row_vector, row_vector)
+real pareto_type_2_lcdf(vector, vector, row_vector, real[])
+real pareto_type_2_lcdf(vector, vector, real[], real)
+real pareto_type_2_lcdf(vector, vector, real[], vector)
+real pareto_type_2_lcdf(vector, vector, real[], row_vector)
+real pareto_type_2_lcdf(vector, vector, real[], real[])
+real pareto_type_2_lcdf(vector, row_vector, real, real)
+real pareto_type_2_lcdf(vector, row_vector, real, vector)
+real pareto_type_2_lcdf(vector, row_vector, real, row_vector)
+real pareto_type_2_lcdf(vector, row_vector, real, real[])
+real pareto_type_2_lcdf(vector, row_vector, vector, real)
+real pareto_type_2_lcdf(vector, row_vector, vector, vector)
+real pareto_type_2_lcdf(vector, row_vector, vector, row_vector)
+real pareto_type_2_lcdf(vector, row_vector, vector, real[])
+real pareto_type_2_lcdf(vector, row_vector, row_vector, real)
+real pareto_type_2_lcdf(vector, row_vector, row_vector, vector)
+real pareto_type_2_lcdf(vector, row_vector, row_vector, row_vector)
+real pareto_type_2_lcdf(vector, row_vector, row_vector, real[])
+real pareto_type_2_lcdf(vector, row_vector, real[], real)
+real pareto_type_2_lcdf(vector, row_vector, real[], vector)
+real pareto_type_2_lcdf(vector, row_vector, real[], row_vector)
+real pareto_type_2_lcdf(vector, row_vector, real[], real[])
+real pareto_type_2_lcdf(vector, real[], real, real)
+real pareto_type_2_lcdf(vector, real[], real, vector)
+real pareto_type_2_lcdf(vector, real[], real, row_vector)
+real pareto_type_2_lcdf(vector, real[], real, real[])
+real pareto_type_2_lcdf(vector, real[], vector, real)
+real pareto_type_2_lcdf(vector, real[], vector, vector)
+real pareto_type_2_lcdf(vector, real[], vector, row_vector)
+real pareto_type_2_lcdf(vector, real[], vector, real[])
+real pareto_type_2_lcdf(vector, real[], row_vector, real)
+real pareto_type_2_lcdf(vector, real[], row_vector, vector)
+real pareto_type_2_lcdf(vector, real[], row_vector, row_vector)
+real pareto_type_2_lcdf(vector, real[], row_vector, real[])
+real pareto_type_2_lcdf(vector, real[], real[], real)
+real pareto_type_2_lcdf(vector, real[], real[], vector)
+real pareto_type_2_lcdf(vector, real[], real[], row_vector)
+real pareto_type_2_lcdf(vector, real[], real[], real[])
+real pareto_type_2_lcdf(row_vector, real, real, real)
+real pareto_type_2_lcdf(row_vector, real, real, vector)
+real pareto_type_2_lcdf(row_vector, real, real, row_vector)
+real pareto_type_2_lcdf(row_vector, real, real, real[])
+real pareto_type_2_lcdf(row_vector, real, vector, real)
+real pareto_type_2_lcdf(row_vector, real, vector, vector)
+real pareto_type_2_lcdf(row_vector, real, vector, row_vector)
+real pareto_type_2_lcdf(row_vector, real, vector, real[])
+real pareto_type_2_lcdf(row_vector, real, row_vector, real)
+real pareto_type_2_lcdf(row_vector, real, row_vector, vector)
+real pareto_type_2_lcdf(row_vector, real, row_vector, row_vector)
+real pareto_type_2_lcdf(row_vector, real, row_vector, real[])
+real pareto_type_2_lcdf(row_vector, real, real[], real)
+real pareto_type_2_lcdf(row_vector, real, real[], vector)
+real pareto_type_2_lcdf(row_vector, real, real[], row_vector)
+real pareto_type_2_lcdf(row_vector, real, real[], real[])
+real pareto_type_2_lcdf(row_vector, vector, real, real)
+real pareto_type_2_lcdf(row_vector, vector, real, vector)
+real pareto_type_2_lcdf(row_vector, vector, real, row_vector)
+real pareto_type_2_lcdf(row_vector, vector, real, real[])
+real pareto_type_2_lcdf(row_vector, vector, vector, real)
+real pareto_type_2_lcdf(row_vector, vector, vector, vector)
+real pareto_type_2_lcdf(row_vector, vector, vector, row_vector)
+real pareto_type_2_lcdf(row_vector, vector, vector, real[])
+real pareto_type_2_lcdf(row_vector, vector, row_vector, real)
+real pareto_type_2_lcdf(row_vector, vector, row_vector, vector)
+real pareto_type_2_lcdf(row_vector, vector, row_vector, row_vector)
+real pareto_type_2_lcdf(row_vector, vector, row_vector, real[])
+real pareto_type_2_lcdf(row_vector, vector, real[], real)
+real pareto_type_2_lcdf(row_vector, vector, real[], vector)
+real pareto_type_2_lcdf(row_vector, vector, real[], row_vector)
+real pareto_type_2_lcdf(row_vector, vector, real[], real[])
+real pareto_type_2_lcdf(row_vector, row_vector, real, real)
+real pareto_type_2_lcdf(row_vector, row_vector, real, vector)
+real pareto_type_2_lcdf(row_vector, row_vector, real, row_vector)
+real pareto_type_2_lcdf(row_vector, row_vector, real, real[])
+real pareto_type_2_lcdf(row_vector, row_vector, vector, real)
+real pareto_type_2_lcdf(row_vector, row_vector, vector, vector)
+real pareto_type_2_lcdf(row_vector, row_vector, vector, row_vector)
+real pareto_type_2_lcdf(row_vector, row_vector, vector, real[])
+real pareto_type_2_lcdf(row_vector, row_vector, row_vector, real)
+real pareto_type_2_lcdf(row_vector, row_vector, row_vector, vector)
+real pareto_type_2_lcdf(row_vector, row_vector, row_vector, row_vector)
+real pareto_type_2_lcdf(row_vector, row_vector, row_vector, real[])
+real pareto_type_2_lcdf(row_vector, row_vector, real[], real)
+real pareto_type_2_lcdf(row_vector, row_vector, real[], vector)
+real pareto_type_2_lcdf(row_vector, row_vector, real[], row_vector)
+real pareto_type_2_lcdf(row_vector, row_vector, real[], real[])
+real pareto_type_2_lcdf(row_vector, real[], real, real)
+real pareto_type_2_lcdf(row_vector, real[], real, vector)
+real pareto_type_2_lcdf(row_vector, real[], real, row_vector)
+real pareto_type_2_lcdf(row_vector, real[], real, real[])
+real pareto_type_2_lcdf(row_vector, real[], vector, real)
+real pareto_type_2_lcdf(row_vector, real[], vector, vector)
+real pareto_type_2_lcdf(row_vector, real[], vector, row_vector)
+real pareto_type_2_lcdf(row_vector, real[], vector, real[])
+real pareto_type_2_lcdf(row_vector, real[], row_vector, real)
+real pareto_type_2_lcdf(row_vector, real[], row_vector, vector)
+real pareto_type_2_lcdf(row_vector, real[], row_vector, row_vector)
+real pareto_type_2_lcdf(row_vector, real[], row_vector, real[])
+real pareto_type_2_lcdf(row_vector, real[], real[], real)
+real pareto_type_2_lcdf(row_vector, real[], real[], vector)
+real pareto_type_2_lcdf(row_vector, real[], real[], row_vector)
+real pareto_type_2_lcdf(row_vector, real[], real[], real[])
+real pareto_type_2_lcdf(real[], real, real, vector)
+real pareto_type_2_lcdf(real[], real, real, row_vector)
+real pareto_type_2_lcdf(real[], real, vector, real)
+real pareto_type_2_lcdf(real[], real, vector, vector)
+real pareto_type_2_lcdf(real[], real, vector, row_vector)
+real pareto_type_2_lcdf(real[], real, vector, real[])
+real pareto_type_2_lcdf(real[], real, row_vector, real)
+real pareto_type_2_lcdf(real[], real, row_vector, vector)
+real pareto_type_2_lcdf(real[], real, row_vector, row_vector)
+real pareto_type_2_lcdf(real[], real, row_vector, real[])
+real pareto_type_2_lcdf(real[], real, real[], vector)
+real pareto_type_2_lcdf(real[], real, real[], row_vector)
+real pareto_type_2_lcdf(real[], vector, real, real)
+real pareto_type_2_lcdf(real[], vector, real, vector)
+real pareto_type_2_lcdf(real[], vector, real, row_vector)
+real pareto_type_2_lcdf(real[], vector, real, real[])
+real pareto_type_2_lcdf(real[], vector, vector, real)
+real pareto_type_2_lcdf(real[], vector, vector, vector)
+real pareto_type_2_lcdf(real[], vector, vector, row_vector)
+real pareto_type_2_lcdf(real[], vector, vector, real[])
+real pareto_type_2_lcdf(real[], vector, row_vector, real)
+real pareto_type_2_lcdf(real[], vector, row_vector, vector)
+real pareto_type_2_lcdf(real[], vector, row_vector, row_vector)
+real pareto_type_2_lcdf(real[], vector, row_vector, real[])
+real pareto_type_2_lcdf(real[], vector, real[], real)
+real pareto_type_2_lcdf(real[], vector, real[], vector)
+real pareto_type_2_lcdf(real[], vector, real[], row_vector)
+real pareto_type_2_lcdf(real[], vector, real[], real[])
+real pareto_type_2_lcdf(real[], row_vector, real, real)
+real pareto_type_2_lcdf(real[], row_vector, real, vector)
+real pareto_type_2_lcdf(real[], row_vector, real, row_vector)
+real pareto_type_2_lcdf(real[], row_vector, real, real[])
+real pareto_type_2_lcdf(real[], row_vector, vector, real)
+real pareto_type_2_lcdf(real[], row_vector, vector, vector)
+real pareto_type_2_lcdf(real[], row_vector, vector, row_vector)
+real pareto_type_2_lcdf(real[], row_vector, vector, real[])
+real pareto_type_2_lcdf(real[], row_vector, row_vector, real)
+real pareto_type_2_lcdf(real[], row_vector, row_vector, vector)
+real pareto_type_2_lcdf(real[], row_vector, row_vector, row_vector)
+real pareto_type_2_lcdf(real[], row_vector, row_vector, real[])
+real pareto_type_2_lcdf(real[], row_vector, real[], real)
+real pareto_type_2_lcdf(real[], row_vector, real[], vector)
+real pareto_type_2_lcdf(real[], row_vector, real[], row_vector)
+real pareto_type_2_lcdf(real[], row_vector, real[], real[])
+real pareto_type_2_lcdf(real[], real[], real, vector)
+real pareto_type_2_lcdf(real[], real[], real, row_vector)
+real pareto_type_2_lcdf(real[], real[], vector, real)
+real pareto_type_2_lcdf(real[], real[], vector, vector)
+real pareto_type_2_lcdf(real[], real[], vector, row_vector)
+real pareto_type_2_lcdf(real[], real[], vector, real[])
+real pareto_type_2_lcdf(real[], real[], row_vector, real)
+real pareto_type_2_lcdf(real[], real[], row_vector, vector)
+real pareto_type_2_lcdf(real[], real[], row_vector, row_vector)
+real pareto_type_2_lcdf(real[], real[], row_vector, real[])
+real pareto_type_2_lcdf(real[], real[], real[], vector)
+real pareto_type_2_lcdf(real[], real[], real[], row_vector)
+real pareto_type_2_log(real, real, real, vector)
+real pareto_type_2_log(real, real, real, row_vector)
+real pareto_type_2_log(real, real, vector, real)
+real pareto_type_2_log(real, real, vector, vector)
+real pareto_type_2_log(real, real, vector, row_vector)
+real pareto_type_2_log(real, real, vector, real[])
+real pareto_type_2_log(real, real, row_vector, real)
+real pareto_type_2_log(real, real, row_vector, vector)
+real pareto_type_2_log(real, real, row_vector, row_vector)
+real pareto_type_2_log(real, real, row_vector, real[])
+real pareto_type_2_log(real, real, real[], vector)
+real pareto_type_2_log(real, real, real[], row_vector)
+real pareto_type_2_log(real, vector, real, real)
+real pareto_type_2_log(real, vector, real, vector)
+real pareto_type_2_log(real, vector, real, row_vector)
+real pareto_type_2_log(real, vector, real, real[])
+real pareto_type_2_log(real, vector, vector, real)
+real pareto_type_2_log(real, vector, vector, vector)
+real pareto_type_2_log(real, vector, vector, row_vector)
+real pareto_type_2_log(real, vector, vector, real[])
+real pareto_type_2_log(real, vector, row_vector, real)
+real pareto_type_2_log(real, vector, row_vector, vector)
+real pareto_type_2_log(real, vector, row_vector, row_vector)
+real pareto_type_2_log(real, vector, row_vector, real[])
+real pareto_type_2_log(real, vector, real[], real)
+real pareto_type_2_log(real, vector, real[], vector)
+real pareto_type_2_log(real, vector, real[], row_vector)
+real pareto_type_2_log(real, vector, real[], real[])
+real pareto_type_2_log(real, row_vector, real, real)
+real pareto_type_2_log(real, row_vector, real, vector)
+real pareto_type_2_log(real, row_vector, real, row_vector)
+real pareto_type_2_log(real, row_vector, real, real[])
+real pareto_type_2_log(real, row_vector, vector, real)
+real pareto_type_2_log(real, row_vector, vector, vector)
+real pareto_type_2_log(real, row_vector, vector, row_vector)
+real pareto_type_2_log(real, row_vector, vector, real[])
+real pareto_type_2_log(real, row_vector, row_vector, real)
+real pareto_type_2_log(real, row_vector, row_vector, vector)
+real pareto_type_2_log(real, row_vector, row_vector, row_vector)
+real pareto_type_2_log(real, row_vector, row_vector, real[])
+real pareto_type_2_log(real, row_vector, real[], real)
+real pareto_type_2_log(real, row_vector, real[], vector)
+real pareto_type_2_log(real, row_vector, real[], row_vector)
+real pareto_type_2_log(real, row_vector, real[], real[])
+real pareto_type_2_log(real, real[], real, vector)
+real pareto_type_2_log(real, real[], real, row_vector)
+real pareto_type_2_log(real, real[], vector, real)
+real pareto_type_2_log(real, real[], vector, vector)
+real pareto_type_2_log(real, real[], vector, row_vector)
+real pareto_type_2_log(real, real[], vector, real[])
+real pareto_type_2_log(real, real[], row_vector, real)
+real pareto_type_2_log(real, real[], row_vector, vector)
+real pareto_type_2_log(real, real[], row_vector, row_vector)
+real pareto_type_2_log(real, real[], row_vector, real[])
+real pareto_type_2_log(real, real[], real[], vector)
+real pareto_type_2_log(real, real[], real[], row_vector)
+real pareto_type_2_log(vector, real, real, real)
+real pareto_type_2_log(vector, real, real, vector)
+real pareto_type_2_log(vector, real, real, row_vector)
+real pareto_type_2_log(vector, real, real, real[])
+real pareto_type_2_log(vector, real, vector, real)
+real pareto_type_2_log(vector, real, vector, vector)
+real pareto_type_2_log(vector, real, vector, row_vector)
+real pareto_type_2_log(vector, real, vector, real[])
+real pareto_type_2_log(vector, real, row_vector, real)
+real pareto_type_2_log(vector, real, row_vector, vector)
+real pareto_type_2_log(vector, real, row_vector, row_vector)
+real pareto_type_2_log(vector, real, row_vector, real[])
+real pareto_type_2_log(vector, real, real[], real)
+real pareto_type_2_log(vector, real, real[], vector)
+real pareto_type_2_log(vector, real, real[], row_vector)
+real pareto_type_2_log(vector, real, real[], real[])
+real pareto_type_2_log(vector, vector, real, real)
+real pareto_type_2_log(vector, vector, real, vector)
+real pareto_type_2_log(vector, vector, real, row_vector)
+real pareto_type_2_log(vector, vector, real, real[])
+real pareto_type_2_log(vector, vector, vector, real)
+real pareto_type_2_log(vector, vector, vector, vector)
+real pareto_type_2_log(vector, vector, vector, row_vector)
+real pareto_type_2_log(vector, vector, vector, real[])
+real pareto_type_2_log(vector, vector, row_vector, real)
+real pareto_type_2_log(vector, vector, row_vector, vector)
+real pareto_type_2_log(vector, vector, row_vector, row_vector)
+real pareto_type_2_log(vector, vector, row_vector, real[])
+real pareto_type_2_log(vector, vector, real[], real)
+real pareto_type_2_log(vector, vector, real[], vector)
+real pareto_type_2_log(vector, vector, real[], row_vector)
+real pareto_type_2_log(vector, vector, real[], real[])
+real pareto_type_2_log(vector, row_vector, real, real)
+real pareto_type_2_log(vector, row_vector, real, vector)
+real pareto_type_2_log(vector, row_vector, real, row_vector)
+real pareto_type_2_log(vector, row_vector, real, real[])
+real pareto_type_2_log(vector, row_vector, vector, real)
+real pareto_type_2_log(vector, row_vector, vector, vector)
+real pareto_type_2_log(vector, row_vector, vector, row_vector)
+real pareto_type_2_log(vector, row_vector, vector, real[])
+real pareto_type_2_log(vector, row_vector, row_vector, real)
+real pareto_type_2_log(vector, row_vector, row_vector, vector)
+real pareto_type_2_log(vector, row_vector, row_vector, row_vector)
+real pareto_type_2_log(vector, row_vector, row_vector, real[])
+real pareto_type_2_log(vector, row_vector, real[], real)
+real pareto_type_2_log(vector, row_vector, real[], vector)
+real pareto_type_2_log(vector, row_vector, real[], row_vector)
+real pareto_type_2_log(vector, row_vector, real[], real[])
+real pareto_type_2_log(vector, real[], real, real)
+real pareto_type_2_log(vector, real[], real, vector)
+real pareto_type_2_log(vector, real[], real, row_vector)
+real pareto_type_2_log(vector, real[], real, real[])
+real pareto_type_2_log(vector, real[], vector, real)
+real pareto_type_2_log(vector, real[], vector, vector)
+real pareto_type_2_log(vector, real[], vector, row_vector)
+real pareto_type_2_log(vector, real[], vector, real[])
+real pareto_type_2_log(vector, real[], row_vector, real)
+real pareto_type_2_log(vector, real[], row_vector, vector)
+real pareto_type_2_log(vector, real[], row_vector, row_vector)
+real pareto_type_2_log(vector, real[], row_vector, real[])
+real pareto_type_2_log(vector, real[], real[], real)
+real pareto_type_2_log(vector, real[], real[], vector)
+real pareto_type_2_log(vector, real[], real[], row_vector)
+real pareto_type_2_log(vector, real[], real[], real[])
+real pareto_type_2_log(row_vector, real, real, real)
+real pareto_type_2_log(row_vector, real, real, vector)
+real pareto_type_2_log(row_vector, real, real, row_vector)
+real pareto_type_2_log(row_vector, real, real, real[])
+real pareto_type_2_log(row_vector, real, vector, real)
+real pareto_type_2_log(row_vector, real, vector, vector)
+real pareto_type_2_log(row_vector, real, vector, row_vector)
+real pareto_type_2_log(row_vector, real, vector, real[])
+real pareto_type_2_log(row_vector, real, row_vector, real)
+real pareto_type_2_log(row_vector, real, row_vector, vector)
+real pareto_type_2_log(row_vector, real, row_vector, row_vector)
+real pareto_type_2_log(row_vector, real, row_vector, real[])
+real pareto_type_2_log(row_vector, real, real[], real)
+real pareto_type_2_log(row_vector, real, real[], vector)
+real pareto_type_2_log(row_vector, real, real[], row_vector)
+real pareto_type_2_log(row_vector, real, real[], real[])
+real pareto_type_2_log(row_vector, vector, real, real)
+real pareto_type_2_log(row_vector, vector, real, vector)
+real pareto_type_2_log(row_vector, vector, real, row_vector)
+real pareto_type_2_log(row_vector, vector, real, real[])
+real pareto_type_2_log(row_vector, vector, vector, real)
+real pareto_type_2_log(row_vector, vector, vector, vector)
+real pareto_type_2_log(row_vector, vector, vector, row_vector)
+real pareto_type_2_log(row_vector, vector, vector, real[])
+real pareto_type_2_log(row_vector, vector, row_vector, real)
+real pareto_type_2_log(row_vector, vector, row_vector, vector)
+real pareto_type_2_log(row_vector, vector, row_vector, row_vector)
+real pareto_type_2_log(row_vector, vector, row_vector, real[])
+real pareto_type_2_log(row_vector, vector, real[], real)
+real pareto_type_2_log(row_vector, vector, real[], vector)
+real pareto_type_2_log(row_vector, vector, real[], row_vector)
+real pareto_type_2_log(row_vector, vector, real[], real[])
+real pareto_type_2_log(row_vector, row_vector, real, real)
+real pareto_type_2_log(row_vector, row_vector, real, vector)
+real pareto_type_2_log(row_vector, row_vector, real, row_vector)
+real pareto_type_2_log(row_vector, row_vector, real, real[])
+real pareto_type_2_log(row_vector, row_vector, vector, real)
+real pareto_type_2_log(row_vector, row_vector, vector, vector)
+real pareto_type_2_log(row_vector, row_vector, vector, row_vector)
+real pareto_type_2_log(row_vector, row_vector, vector, real[])
+real pareto_type_2_log(row_vector, row_vector, row_vector, real)
+real pareto_type_2_log(row_vector, row_vector, row_vector, vector)
+real pareto_type_2_log(row_vector, row_vector, row_vector, row_vector)
+real pareto_type_2_log(row_vector, row_vector, row_vector, real[])
+real pareto_type_2_log(row_vector, row_vector, real[], real)
+real pareto_type_2_log(row_vector, row_vector, real[], vector)
+real pareto_type_2_log(row_vector, row_vector, real[], row_vector)
+real pareto_type_2_log(row_vector, row_vector, real[], real[])
+real pareto_type_2_log(row_vector, real[], real, real)
+real pareto_type_2_log(row_vector, real[], real, vector)
+real pareto_type_2_log(row_vector, real[], real, row_vector)
+real pareto_type_2_log(row_vector, real[], real, real[])
+real pareto_type_2_log(row_vector, real[], vector, real)
+real pareto_type_2_log(row_vector, real[], vector, vector)
+real pareto_type_2_log(row_vector, real[], vector, row_vector)
+real pareto_type_2_log(row_vector, real[], vector, real[])
+real pareto_type_2_log(row_vector, real[], row_vector, real)
+real pareto_type_2_log(row_vector, real[], row_vector, vector)
+real pareto_type_2_log(row_vector, real[], row_vector, row_vector)
+real pareto_type_2_log(row_vector, real[], row_vector, real[])
+real pareto_type_2_log(row_vector, real[], real[], real)
+real pareto_type_2_log(row_vector, real[], real[], vector)
+real pareto_type_2_log(row_vector, real[], real[], row_vector)
+real pareto_type_2_log(row_vector, real[], real[], real[])
+real pareto_type_2_log(real[], real, real, vector)
+real pareto_type_2_log(real[], real, real, row_vector)
+real pareto_type_2_log(real[], real, vector, real)
+real pareto_type_2_log(real[], real, vector, vector)
+real pareto_type_2_log(real[], real, vector, row_vector)
+real pareto_type_2_log(real[], real, vector, real[])
+real pareto_type_2_log(real[], real, row_vector, real)
+real pareto_type_2_log(real[], real, row_vector, vector)
+real pareto_type_2_log(real[], real, row_vector, row_vector)
+real pareto_type_2_log(real[], real, row_vector, real[])
+real pareto_type_2_log(real[], real, real[], vector)
+real pareto_type_2_log(real[], real, real[], row_vector)
+real pareto_type_2_log(real[], vector, real, real)
+real pareto_type_2_log(real[], vector, real, vector)
+real pareto_type_2_log(real[], vector, real, row_vector)
+real pareto_type_2_log(real[], vector, real, real[])
+real pareto_type_2_log(real[], vector, vector, real)
+real pareto_type_2_log(real[], vector, vector, vector)
+real pareto_type_2_log(real[], vector, vector, row_vector)
+real pareto_type_2_log(real[], vector, vector, real[])
+real pareto_type_2_log(real[], vector, row_vector, real)
+real pareto_type_2_log(real[], vector, row_vector, vector)
+real pareto_type_2_log(real[], vector, row_vector, row_vector)
+real pareto_type_2_log(real[], vector, row_vector, real[])
+real pareto_type_2_log(real[], vector, real[], real)
+real pareto_type_2_log(real[], vector, real[], vector)
+real pareto_type_2_log(real[], vector, real[], row_vector)
+real pareto_type_2_log(real[], vector, real[], real[])
+real pareto_type_2_log(real[], row_vector, real, real)
+real pareto_type_2_log(real[], row_vector, real, vector)
+real pareto_type_2_log(real[], row_vector, real, row_vector)
+real pareto_type_2_log(real[], row_vector, real, real[])
+real pareto_type_2_log(real[], row_vector, vector, real)
+real pareto_type_2_log(real[], row_vector, vector, vector)
+real pareto_type_2_log(real[], row_vector, vector, row_vector)
+real pareto_type_2_log(real[], row_vector, vector, real[])
+real pareto_type_2_log(real[], row_vector, row_vector, real)
+real pareto_type_2_log(real[], row_vector, row_vector, vector)
+real pareto_type_2_log(real[], row_vector, row_vector, row_vector)
+real pareto_type_2_log(real[], row_vector, row_vector, real[])
+real pareto_type_2_log(real[], row_vector, real[], real)
+real pareto_type_2_log(real[], row_vector, real[], vector)
+real pareto_type_2_log(real[], row_vector, real[], row_vector)
+real pareto_type_2_log(real[], row_vector, real[], real[])
+real pareto_type_2_log(real[], real[], real, vector)
+real pareto_type_2_log(real[], real[], real, row_vector)
+real pareto_type_2_log(real[], real[], vector, real)
+real pareto_type_2_log(real[], real[], vector, vector)
+real pareto_type_2_log(real[], real[], vector, row_vector)
+real pareto_type_2_log(real[], real[], vector, real[])
+real pareto_type_2_log(real[], real[], row_vector, real)
+real pareto_type_2_log(real[], real[], row_vector, vector)
+real pareto_type_2_log(real[], real[], row_vector, row_vector)
+real pareto_type_2_log(real[], real[], row_vector, real[])
+real pareto_type_2_log(real[], real[], real[], vector)
+real pareto_type_2_log(real[], real[], real[], row_vector)
+real pareto_type_2_lpdf(real, real, real, vector)
+real pareto_type_2_lpdf(real, real, real, row_vector)
+real pareto_type_2_lpdf(real, real, vector, real)
+real pareto_type_2_lpdf(real, real, vector, vector)
+real pareto_type_2_lpdf(real, real, vector, row_vector)
+real pareto_type_2_lpdf(real, real, vector, real[])
+real pareto_type_2_lpdf(real, real, row_vector, real)
+real pareto_type_2_lpdf(real, real, row_vector, vector)
+real pareto_type_2_lpdf(real, real, row_vector, row_vector)
+real pareto_type_2_lpdf(real, real, row_vector, real[])
+real pareto_type_2_lpdf(real, real, real[], vector)
+real pareto_type_2_lpdf(real, real, real[], row_vector)
+real pareto_type_2_lpdf(real, vector, real, real)
+real pareto_type_2_lpdf(real, vector, real, vector)
+real pareto_type_2_lpdf(real, vector, real, row_vector)
+real pareto_type_2_lpdf(real, vector, real, real[])
+real pareto_type_2_lpdf(real, vector, vector, real)
+real pareto_type_2_lpdf(real, vector, vector, vector)
+real pareto_type_2_lpdf(real, vector, vector, row_vector)
+real pareto_type_2_lpdf(real, vector, vector, real[])
+real pareto_type_2_lpdf(real, vector, row_vector, real)
+real pareto_type_2_lpdf(real, vector, row_vector, vector)
+real pareto_type_2_lpdf(real, vector, row_vector, row_vector)
+real pareto_type_2_lpdf(real, vector, row_vector, real[])
+real pareto_type_2_lpdf(real, vector, real[], real)
+real pareto_type_2_lpdf(real, vector, real[], vector)
+real pareto_type_2_lpdf(real, vector, real[], row_vector)
+real pareto_type_2_lpdf(real, vector, real[], real[])
+real pareto_type_2_lpdf(real, row_vector, real, real)
+real pareto_type_2_lpdf(real, row_vector, real, vector)
+real pareto_type_2_lpdf(real, row_vector, real, row_vector)
+real pareto_type_2_lpdf(real, row_vector, real, real[])
+real pareto_type_2_lpdf(real, row_vector, vector, real)
+real pareto_type_2_lpdf(real, row_vector, vector, vector)
+real pareto_type_2_lpdf(real, row_vector, vector, row_vector)
+real pareto_type_2_lpdf(real, row_vector, vector, real[])
+real pareto_type_2_lpdf(real, row_vector, row_vector, real)
+real pareto_type_2_lpdf(real, row_vector, row_vector, vector)
+real pareto_type_2_lpdf(real, row_vector, row_vector, row_vector)
+real pareto_type_2_lpdf(real, row_vector, row_vector, real[])
+real pareto_type_2_lpdf(real, row_vector, real[], real)
+real pareto_type_2_lpdf(real, row_vector, real[], vector)
+real pareto_type_2_lpdf(real, row_vector, real[], row_vector)
+real pareto_type_2_lpdf(real, row_vector, real[], real[])
+real pareto_type_2_lpdf(real, real[], real, vector)
+real pareto_type_2_lpdf(real, real[], real, row_vector)
+real pareto_type_2_lpdf(real, real[], vector, real)
+real pareto_type_2_lpdf(real, real[], vector, vector)
+real pareto_type_2_lpdf(real, real[], vector, row_vector)
+real pareto_type_2_lpdf(real, real[], vector, real[])
+real pareto_type_2_lpdf(real, real[], row_vector, real)
+real pareto_type_2_lpdf(real, real[], row_vector, vector)
+real pareto_type_2_lpdf(real, real[], row_vector, row_vector)
+real pareto_type_2_lpdf(real, real[], row_vector, real[])
+real pareto_type_2_lpdf(real, real[], real[], vector)
+real pareto_type_2_lpdf(real, real[], real[], row_vector)
+real pareto_type_2_lpdf(vector, real, real, real)
+real pareto_type_2_lpdf(vector, real, real, vector)
+real pareto_type_2_lpdf(vector, real, real, row_vector)
+real pareto_type_2_lpdf(vector, real, real, real[])
+real pareto_type_2_lpdf(vector, real, vector, real)
+real pareto_type_2_lpdf(vector, real, vector, vector)
+real pareto_type_2_lpdf(vector, real, vector, row_vector)
+real pareto_type_2_lpdf(vector, real, vector, real[])
+real pareto_type_2_lpdf(vector, real, row_vector, real)
+real pareto_type_2_lpdf(vector, real, row_vector, vector)
+real pareto_type_2_lpdf(vector, real, row_vector, row_vector)
+real pareto_type_2_lpdf(vector, real, row_vector, real[])
+real pareto_type_2_lpdf(vector, real, real[], real)
+real pareto_type_2_lpdf(vector, real, real[], vector)
+real pareto_type_2_lpdf(vector, real, real[], row_vector)
+real pareto_type_2_lpdf(vector, real, real[], real[])
+real pareto_type_2_lpdf(vector, vector, real, real)
+real pareto_type_2_lpdf(vector, vector, real, vector)
+real pareto_type_2_lpdf(vector, vector, real, row_vector)
+real pareto_type_2_lpdf(vector, vector, real, real[])
+real pareto_type_2_lpdf(vector, vector, vector, real)
+real pareto_type_2_lpdf(vector, vector, vector, vector)
+real pareto_type_2_lpdf(vector, vector, vector, row_vector)
+real pareto_type_2_lpdf(vector, vector, vector, real[])
+real pareto_type_2_lpdf(vector, vector, row_vector, real)
+real pareto_type_2_lpdf(vector, vector, row_vector, vector)
+real pareto_type_2_lpdf(vector, vector, row_vector, row_vector)
+real pareto_type_2_lpdf(vector, vector, row_vector, real[])
+real pareto_type_2_lpdf(vector, vector, real[], real)
+real pareto_type_2_lpdf(vector, vector, real[], vector)
+real pareto_type_2_lpdf(vector, vector, real[], row_vector)
+real pareto_type_2_lpdf(vector, vector, real[], real[])
+real pareto_type_2_lpdf(vector, row_vector, real, real)
+real pareto_type_2_lpdf(vector, row_vector, real, vector)
+real pareto_type_2_lpdf(vector, row_vector, real, row_vector)
+real pareto_type_2_lpdf(vector, row_vector, real, real[])
+real pareto_type_2_lpdf(vector, row_vector, vector, real)
+real pareto_type_2_lpdf(vector, row_vector, vector, vector)
+real pareto_type_2_lpdf(vector, row_vector, vector, row_vector)
+real pareto_type_2_lpdf(vector, row_vector, vector, real[])
+real pareto_type_2_lpdf(vector, row_vector, row_vector, real)
+real pareto_type_2_lpdf(vector, row_vector, row_vector, vector)
+real pareto_type_2_lpdf(vector, row_vector, row_vector, row_vector)
+real pareto_type_2_lpdf(vector, row_vector, row_vector, real[])
+real pareto_type_2_lpdf(vector, row_vector, real[], real)
+real pareto_type_2_lpdf(vector, row_vector, real[], vector)
+real pareto_type_2_lpdf(vector, row_vector, real[], row_vector)
+real pareto_type_2_lpdf(vector, row_vector, real[], real[])
+real pareto_type_2_lpdf(vector, real[], real, real)
+real pareto_type_2_lpdf(vector, real[], real, vector)
+real pareto_type_2_lpdf(vector, real[], real, row_vector)
+real pareto_type_2_lpdf(vector, real[], real, real[])
+real pareto_type_2_lpdf(vector, real[], vector, real)
+real pareto_type_2_lpdf(vector, real[], vector, vector)
+real pareto_type_2_lpdf(vector, real[], vector, row_vector)
+real pareto_type_2_lpdf(vector, real[], vector, real[])
+real pareto_type_2_lpdf(vector, real[], row_vector, real)
+real pareto_type_2_lpdf(vector, real[], row_vector, vector)
+real pareto_type_2_lpdf(vector, real[], row_vector, row_vector)
+real pareto_type_2_lpdf(vector, real[], row_vector, real[])
+real pareto_type_2_lpdf(vector, real[], real[], real)
+real pareto_type_2_lpdf(vector, real[], real[], vector)
+real pareto_type_2_lpdf(vector, real[], real[], row_vector)
+real pareto_type_2_lpdf(vector, real[], real[], real[])
+real pareto_type_2_lpdf(row_vector, real, real, real)
+real pareto_type_2_lpdf(row_vector, real, real, vector)
+real pareto_type_2_lpdf(row_vector, real, real, row_vector)
+real pareto_type_2_lpdf(row_vector, real, real, real[])
+real pareto_type_2_lpdf(row_vector, real, vector, real)
+real pareto_type_2_lpdf(row_vector, real, vector, vector)
+real pareto_type_2_lpdf(row_vector, real, vector, row_vector)
+real pareto_type_2_lpdf(row_vector, real, vector, real[])
+real pareto_type_2_lpdf(row_vector, real, row_vector, real)
+real pareto_type_2_lpdf(row_vector, real, row_vector, vector)
+real pareto_type_2_lpdf(row_vector, real, row_vector, row_vector)
+real pareto_type_2_lpdf(row_vector, real, row_vector, real[])
+real pareto_type_2_lpdf(row_vector, real, real[], real)
+real pareto_type_2_lpdf(row_vector, real, real[], vector)
+real pareto_type_2_lpdf(row_vector, real, real[], row_vector)
+real pareto_type_2_lpdf(row_vector, real, real[], real[])
+real pareto_type_2_lpdf(row_vector, vector, real, real)
+real pareto_type_2_lpdf(row_vector, vector, real, vector)
+real pareto_type_2_lpdf(row_vector, vector, real, row_vector)
+real pareto_type_2_lpdf(row_vector, vector, real, real[])
+real pareto_type_2_lpdf(row_vector, vector, vector, real)
+real pareto_type_2_lpdf(row_vector, vector, vector, vector)
+real pareto_type_2_lpdf(row_vector, vector, vector, row_vector)
+real pareto_type_2_lpdf(row_vector, vector, vector, real[])
+real pareto_type_2_lpdf(row_vector, vector, row_vector, real)
+real pareto_type_2_lpdf(row_vector, vector, row_vector, vector)
+real pareto_type_2_lpdf(row_vector, vector, row_vector, row_vector)
+real pareto_type_2_lpdf(row_vector, vector, row_vector, real[])
+real pareto_type_2_lpdf(row_vector, vector, real[], real)
+real pareto_type_2_lpdf(row_vector, vector, real[], vector)
+real pareto_type_2_lpdf(row_vector, vector, real[], row_vector)
+real pareto_type_2_lpdf(row_vector, vector, real[], real[])
+real pareto_type_2_lpdf(row_vector, row_vector, real, real)
+real pareto_type_2_lpdf(row_vector, row_vector, real, vector)
+real pareto_type_2_lpdf(row_vector, row_vector, real, row_vector)
+real pareto_type_2_lpdf(row_vector, row_vector, real, real[])
+real pareto_type_2_lpdf(row_vector, row_vector, vector, real)
+real pareto_type_2_lpdf(row_vector, row_vector, vector, vector)
+real pareto_type_2_lpdf(row_vector, row_vector, vector, row_vector)
+real pareto_type_2_lpdf(row_vector, row_vector, vector, real[])
+real pareto_type_2_lpdf(row_vector, row_vector, row_vector, real)
+real pareto_type_2_lpdf(row_vector, row_vector, row_vector, vector)
+real pareto_type_2_lpdf(row_vector, row_vector, row_vector, row_vector)
+real pareto_type_2_lpdf(row_vector, row_vector, row_vector, real[])
+real pareto_type_2_lpdf(row_vector, row_vector, real[], real)
+real pareto_type_2_lpdf(row_vector, row_vector, real[], vector)
+real pareto_type_2_lpdf(row_vector, row_vector, real[], row_vector)
+real pareto_type_2_lpdf(row_vector, row_vector, real[], real[])
+real pareto_type_2_lpdf(row_vector, real[], real, real)
+real pareto_type_2_lpdf(row_vector, real[], real, vector)
+real pareto_type_2_lpdf(row_vector, real[], real, row_vector)
+real pareto_type_2_lpdf(row_vector, real[], real, real[])
+real pareto_type_2_lpdf(row_vector, real[], vector, real)
+real pareto_type_2_lpdf(row_vector, real[], vector, vector)
+real pareto_type_2_lpdf(row_vector, real[], vector, row_vector)
+real pareto_type_2_lpdf(row_vector, real[], vector, real[])
+real pareto_type_2_lpdf(row_vector, real[], row_vector, real)
+real pareto_type_2_lpdf(row_vector, real[], row_vector, vector)
+real pareto_type_2_lpdf(row_vector, real[], row_vector, row_vector)
+real pareto_type_2_lpdf(row_vector, real[], row_vector, real[])
+real pareto_type_2_lpdf(row_vector, real[], real[], real)
+real pareto_type_2_lpdf(row_vector, real[], real[], vector)
+real pareto_type_2_lpdf(row_vector, real[], real[], row_vector)
+real pareto_type_2_lpdf(row_vector, real[], real[], real[])
+real pareto_type_2_lpdf(real[], real, real, vector)
+real pareto_type_2_lpdf(real[], real, real, row_vector)
+real pareto_type_2_lpdf(real[], real, vector, real)
+real pareto_type_2_lpdf(real[], real, vector, vector)
+real pareto_type_2_lpdf(real[], real, vector, row_vector)
+real pareto_type_2_lpdf(real[], real, vector, real[])
+real pareto_type_2_lpdf(real[], real, row_vector, real)
+real pareto_type_2_lpdf(real[], real, row_vector, vector)
+real pareto_type_2_lpdf(real[], real, row_vector, row_vector)
+real pareto_type_2_lpdf(real[], real, row_vector, real[])
+real pareto_type_2_lpdf(real[], real, real[], vector)
+real pareto_type_2_lpdf(real[], real, real[], row_vector)
+real pareto_type_2_lpdf(real[], vector, real, real)
+real pareto_type_2_lpdf(real[], vector, real, vector)
+real pareto_type_2_lpdf(real[], vector, real, row_vector)
+real pareto_type_2_lpdf(real[], vector, real, real[])
+real pareto_type_2_lpdf(real[], vector, vector, real)
+real pareto_type_2_lpdf(real[], vector, vector, vector)
+real pareto_type_2_lpdf(real[], vector, vector, row_vector)
+real pareto_type_2_lpdf(real[], vector, vector, real[])
+real pareto_type_2_lpdf(real[], vector, row_vector, real)
+real pareto_type_2_lpdf(real[], vector, row_vector, vector)
+real pareto_type_2_lpdf(real[], vector, row_vector, row_vector)
+real pareto_type_2_lpdf(real[], vector, row_vector, real[])
+real pareto_type_2_lpdf(real[], vector, real[], real)
+real pareto_type_2_lpdf(real[], vector, real[], vector)
+real pareto_type_2_lpdf(real[], vector, real[], row_vector)
+real pareto_type_2_lpdf(real[], vector, real[], real[])
+real pareto_type_2_lpdf(real[], row_vector, real, real)
+real pareto_type_2_lpdf(real[], row_vector, real, vector)
+real pareto_type_2_lpdf(real[], row_vector, real, row_vector)
+real pareto_type_2_lpdf(real[], row_vector, real, real[])
+real pareto_type_2_lpdf(real[], row_vector, vector, real)
+real pareto_type_2_lpdf(real[], row_vector, vector, vector)
+real pareto_type_2_lpdf(real[], row_vector, vector, row_vector)
+real pareto_type_2_lpdf(real[], row_vector, vector, real[])
+real pareto_type_2_lpdf(real[], row_vector, row_vector, real)
+real pareto_type_2_lpdf(real[], row_vector, row_vector, vector)
+real pareto_type_2_lpdf(real[], row_vector, row_vector, row_vector)
+real pareto_type_2_lpdf(real[], row_vector, row_vector, real[])
+real pareto_type_2_lpdf(real[], row_vector, real[], real)
+real pareto_type_2_lpdf(real[], row_vector, real[], vector)
+real pareto_type_2_lpdf(real[], row_vector, real[], row_vector)
+real pareto_type_2_lpdf(real[], row_vector, real[], real[])
+real pareto_type_2_lpdf(real[], real[], real, vector)
+real pareto_type_2_lpdf(real[], real[], real, row_vector)
+real pareto_type_2_lpdf(real[], real[], vector, real)
+real pareto_type_2_lpdf(real[], real[], vector, vector)
+real pareto_type_2_lpdf(real[], real[], vector, row_vector)
+real pareto_type_2_lpdf(real[], real[], vector, real[])
+real pareto_type_2_lpdf(real[], real[], row_vector, real)
+real pareto_type_2_lpdf(real[], real[], row_vector, vector)
+real pareto_type_2_lpdf(real[], real[], row_vector, row_vector)
+real pareto_type_2_lpdf(real[], real[], row_vector, real[])
+real pareto_type_2_lpdf(real[], real[], real[], vector)
+real pareto_type_2_lpdf(real[], real[], real[], row_vector)
+real[] pareto_type_2_rng(int, int, vector)
+real[] pareto_type_2_rng(int, int, row_vector)
+real[] pareto_type_2_rng(int, real, vector)
+real[] pareto_type_2_rng(int, real, row_vector)
+real[] pareto_type_2_rng(int, vector, int)
+real[] pareto_type_2_rng(int, vector, real)
+real[] pareto_type_2_rng(int, vector, vector)
+real[] pareto_type_2_rng(int, vector, row_vector)
+real[] pareto_type_2_rng(int, vector, int[])
+real[] pareto_type_2_rng(int, vector, real[])
+real[] pareto_type_2_rng(int, row_vector, int)
+real[] pareto_type_2_rng(int, row_vector, real)
+real[] pareto_type_2_rng(int, row_vector, vector)
+real[] pareto_type_2_rng(int, row_vector, row_vector)
+real[] pareto_type_2_rng(int, row_vector, int[])
+real[] pareto_type_2_rng(int, row_vector, real[])
+real[] pareto_type_2_rng(int, int[], vector)
+real[] pareto_type_2_rng(int, int[], row_vector)
+real[] pareto_type_2_rng(int, real[], vector)
+real[] pareto_type_2_rng(int, real[], row_vector)
+real[] pareto_type_2_rng(real, int, vector)
+real[] pareto_type_2_rng(real, int, row_vector)
+real[] pareto_type_2_rng(real, real, vector)
+real[] pareto_type_2_rng(real, real, row_vector)
+real[] pareto_type_2_rng(real, vector, int)
+real[] pareto_type_2_rng(real, vector, real)
+real[] pareto_type_2_rng(real, vector, vector)
+real[] pareto_type_2_rng(real, vector, row_vector)
+real[] pareto_type_2_rng(real, vector, int[])
+real[] pareto_type_2_rng(real, vector, real[])
+real[] pareto_type_2_rng(real, row_vector, int)
+real[] pareto_type_2_rng(real, row_vector, real)
+real[] pareto_type_2_rng(real, row_vector, vector)
+real[] pareto_type_2_rng(real, row_vector, row_vector)
+real[] pareto_type_2_rng(real, row_vector, int[])
+real[] pareto_type_2_rng(real, row_vector, real[])
+real[] pareto_type_2_rng(real, int[], vector)
+real[] pareto_type_2_rng(real, int[], row_vector)
+real[] pareto_type_2_rng(real, real[], vector)
+real[] pareto_type_2_rng(real, real[], row_vector)
+real[] pareto_type_2_rng(vector, int, int)
+real[] pareto_type_2_rng(vector, int, real)
+real[] pareto_type_2_rng(vector, int, vector)
+real[] pareto_type_2_rng(vector, int, row_vector)
+real[] pareto_type_2_rng(vector, int, int[])
+real[] pareto_type_2_rng(vector, int, real[])
+real[] pareto_type_2_rng(vector, real, int)
+real[] pareto_type_2_rng(vector, real, real)
+real[] pareto_type_2_rng(vector, real, vector)
+real[] pareto_type_2_rng(vector, real, row_vector)
+real[] pareto_type_2_rng(vector, real, int[])
+real[] pareto_type_2_rng(vector, real, real[])
+real[] pareto_type_2_rng(vector, vector, int)
+real[] pareto_type_2_rng(vector, vector, real)
+real[] pareto_type_2_rng(vector, vector, vector)
+real[] pareto_type_2_rng(vector, vector, row_vector)
+real[] pareto_type_2_rng(vector, vector, int[])
+real[] pareto_type_2_rng(vector, vector, real[])
+real[] pareto_type_2_rng(vector, row_vector, int)
+real[] pareto_type_2_rng(vector, row_vector, real)
+real[] pareto_type_2_rng(vector, row_vector, vector)
+real[] pareto_type_2_rng(vector, row_vector, row_vector)
+real[] pareto_type_2_rng(vector, row_vector, int[])
+real[] pareto_type_2_rng(vector, row_vector, real[])
+real[] pareto_type_2_rng(vector, int[], int)
+real[] pareto_type_2_rng(vector, int[], real)
+real[] pareto_type_2_rng(vector, int[], vector)
+real[] pareto_type_2_rng(vector, int[], row_vector)
+real[] pareto_type_2_rng(vector, int[], int[])
+real[] pareto_type_2_rng(vector, int[], real[])
+real[] pareto_type_2_rng(vector, real[], int)
+real[] pareto_type_2_rng(vector, real[], real)
+real[] pareto_type_2_rng(vector, real[], vector)
+real[] pareto_type_2_rng(vector, real[], row_vector)
+real[] pareto_type_2_rng(vector, real[], int[])
+real[] pareto_type_2_rng(vector, real[], real[])
+real[] pareto_type_2_rng(row_vector, int, int)
+real[] pareto_type_2_rng(row_vector, int, real)
+real[] pareto_type_2_rng(row_vector, int, vector)
+real[] pareto_type_2_rng(row_vector, int, row_vector)
+real[] pareto_type_2_rng(row_vector, int, int[])
+real[] pareto_type_2_rng(row_vector, int, real[])
+real[] pareto_type_2_rng(row_vector, real, int)
+real[] pareto_type_2_rng(row_vector, real, real)
+real[] pareto_type_2_rng(row_vector, real, vector)
+real[] pareto_type_2_rng(row_vector, real, row_vector)
+real[] pareto_type_2_rng(row_vector, real, int[])
+real[] pareto_type_2_rng(row_vector, real, real[])
+real[] pareto_type_2_rng(row_vector, vector, int)
+real[] pareto_type_2_rng(row_vector, vector, real)
+real[] pareto_type_2_rng(row_vector, vector, vector)
+real[] pareto_type_2_rng(row_vector, vector, row_vector)
+real[] pareto_type_2_rng(row_vector, vector, int[])
+real[] pareto_type_2_rng(row_vector, vector, real[])
+real[] pareto_type_2_rng(row_vector, row_vector, int)
+real[] pareto_type_2_rng(row_vector, row_vector, real)
+real[] pareto_type_2_rng(row_vector, row_vector, vector)
+real[] pareto_type_2_rng(row_vector, row_vector, row_vector)
+real[] pareto_type_2_rng(row_vector, row_vector, int[])
+real[] pareto_type_2_rng(row_vector, row_vector, real[])
+real[] pareto_type_2_rng(row_vector, int[], int)
+real[] pareto_type_2_rng(row_vector, int[], real)
+real[] pareto_type_2_rng(row_vector, int[], vector)
+real[] pareto_type_2_rng(row_vector, int[], row_vector)
+real[] pareto_type_2_rng(row_vector, int[], int[])
+real[] pareto_type_2_rng(row_vector, int[], real[])
+real[] pareto_type_2_rng(row_vector, real[], int)
+real[] pareto_type_2_rng(row_vector, real[], real)
+real[] pareto_type_2_rng(row_vector, real[], vector)
+real[] pareto_type_2_rng(row_vector, real[], row_vector)
+real[] pareto_type_2_rng(row_vector, real[], int[])
+real[] pareto_type_2_rng(row_vector, real[], real[])
+real[] pareto_type_2_rng(int[], int, vector)
+real[] pareto_type_2_rng(int[], int, row_vector)
+real[] pareto_type_2_rng(int[], real, vector)
+real[] pareto_type_2_rng(int[], real, row_vector)
+real[] pareto_type_2_rng(int[], vector, int)
+real[] pareto_type_2_rng(int[], vector, real)
+real[] pareto_type_2_rng(int[], vector, vector)
+real[] pareto_type_2_rng(int[], vector, row_vector)
+real[] pareto_type_2_rng(int[], vector, int[])
+real[] pareto_type_2_rng(int[], vector, real[])
+real[] pareto_type_2_rng(int[], row_vector, int)
+real[] pareto_type_2_rng(int[], row_vector, real)
+real[] pareto_type_2_rng(int[], row_vector, vector)
+real[] pareto_type_2_rng(int[], row_vector, row_vector)
+real[] pareto_type_2_rng(int[], row_vector, int[])
+real[] pareto_type_2_rng(int[], row_vector, real[])
+real[] pareto_type_2_rng(int[], int[], vector)
+real[] pareto_type_2_rng(int[], int[], row_vector)
+real[] pareto_type_2_rng(int[], real[], vector)
+real[] pareto_type_2_rng(int[], real[], row_vector)
+real[] pareto_type_2_rng(real[], int, vector)
+real[] pareto_type_2_rng(real[], int, row_vector)
+real[] pareto_type_2_rng(real[], real, vector)
+real[] pareto_type_2_rng(real[], real, row_vector)
+real[] pareto_type_2_rng(real[], vector, int)
+real[] pareto_type_2_rng(real[], vector, real)
+real[] pareto_type_2_rng(real[], vector, vector)
+real[] pareto_type_2_rng(real[], vector, row_vector)
+real[] pareto_type_2_rng(real[], vector, int[])
+real[] pareto_type_2_rng(real[], vector, real[])
+real[] pareto_type_2_rng(real[], row_vector, int)
+real[] pareto_type_2_rng(real[], row_vector, real)
+real[] pareto_type_2_rng(real[], row_vector, vector)
+real[] pareto_type_2_rng(real[], row_vector, row_vector)
+real[] pareto_type_2_rng(real[], row_vector, int[])
+real[] pareto_type_2_rng(real[], row_vector, real[])
+real[] pareto_type_2_rng(real[], int[], vector)
+real[] pareto_type_2_rng(real[], int[], row_vector)
+real[] pareto_type_2_rng(real[], real[], vector)
+real[] pareto_type_2_rng(real[], real[], row_vector)
+vector plus(vector)
+row_vector plus(row_vector)
+matrix plus(matrix)
+real poisson_ccdf_log(int, vector)
+real poisson_ccdf_log(int, row_vector)
+real poisson_ccdf_log(int[], vector)
+real poisson_ccdf_log(int[], row_vector)
+real poisson_cdf(int, vector)
+real poisson_cdf(int, row_vector)
+real poisson_cdf(int[], vector)
+real poisson_cdf(int[], row_vector)
+real poisson_cdf_log(int, vector)
+real poisson_cdf_log(int, row_vector)
+real poisson_cdf_log(int[], vector)
+real poisson_cdf_log(int[], row_vector)
+real poisson_lccdf(int, vector)
+real poisson_lccdf(int, row_vector)
+real poisson_lccdf(int[], vector)
+real poisson_lccdf(int[], row_vector)
+real poisson_lcdf(int, vector)
+real poisson_lcdf(int, row_vector)
+real poisson_lcdf(int[], vector)
+real poisson_lcdf(int[], row_vector)
+real poisson_log(int, vector)
+real poisson_log(int, row_vector)
+real poisson_log(int[], vector)
+real poisson_log(int[], row_vector)
+real poisson_log_log(int, vector)
+real poisson_log_log(int, row_vector)
+real poisson_log_log(int[], vector)
+real poisson_log_log(int[], row_vector)
+real poisson_log_lpmf(int, vector)
+real poisson_log_lpmf(int, row_vector)
+real poisson_log_lpmf(int[], vector)
+real poisson_log_lpmf(int[], row_vector)
+int[] poisson_log_rng(vector)
+int[] poisson_log_rng(row_vector)
+real poisson_lpmf(int, vector)
+real poisson_lpmf(int, row_vector)
+real poisson_lpmf(int[], vector)
+real poisson_lpmf(int[], row_vector)
+int[] poisson_rng(vector)
+int[] poisson_rng(row_vector)
+real rayleigh_ccdf_log(real, vector)
+real rayleigh_ccdf_log(real, row_vector)
+real rayleigh_ccdf_log(vector, real)
+real rayleigh_ccdf_log(vector, vector)
+real rayleigh_ccdf_log(vector, row_vector)
+real rayleigh_ccdf_log(vector, real[])
+real rayleigh_ccdf_log(row_vector, real)
+real rayleigh_ccdf_log(row_vector, vector)
+real rayleigh_ccdf_log(row_vector, row_vector)
+real rayleigh_ccdf_log(row_vector, real[])
+real rayleigh_ccdf_log(real[], vector)
+real rayleigh_ccdf_log(real[], row_vector)
+real rayleigh_cdf(real, vector)
+real rayleigh_cdf(real, row_vector)
+real rayleigh_cdf(vector, real)
+real rayleigh_cdf(vector, vector)
+real rayleigh_cdf(vector, row_vector)
+real rayleigh_cdf(vector, real[])
+real rayleigh_cdf(row_vector, real)
+real rayleigh_cdf(row_vector, vector)
+real rayleigh_cdf(row_vector, row_vector)
+real rayleigh_cdf(row_vector, real[])
+real rayleigh_cdf(real[], vector)
+real rayleigh_cdf(real[], row_vector)
+real rayleigh_cdf_log(real, vector)
+real rayleigh_cdf_log(real, row_vector)
+real rayleigh_cdf_log(vector, real)
+real rayleigh_cdf_log(vector, vector)
+real rayleigh_cdf_log(vector, row_vector)
+real rayleigh_cdf_log(vector, real[])
+real rayleigh_cdf_log(row_vector, real)
+real rayleigh_cdf_log(row_vector, vector)
+real rayleigh_cdf_log(row_vector, row_vector)
+real rayleigh_cdf_log(row_vector, real[])
+real rayleigh_cdf_log(real[], vector)
+real rayleigh_cdf_log(real[], row_vector)
+real rayleigh_lccdf(real, vector)
+real rayleigh_lccdf(real, row_vector)
+real rayleigh_lccdf(vector, real)
+real rayleigh_lccdf(vector, vector)
+real rayleigh_lccdf(vector, row_vector)
+real rayleigh_lccdf(vector, real[])
+real rayleigh_lccdf(row_vector, real)
+real rayleigh_lccdf(row_vector, vector)
+real rayleigh_lccdf(row_vector, row_vector)
+real rayleigh_lccdf(row_vector, real[])
+real rayleigh_lccdf(real[], vector)
+real rayleigh_lccdf(real[], row_vector)
+real rayleigh_lcdf(real, vector)
+real rayleigh_lcdf(real, row_vector)
+real rayleigh_lcdf(vector, real)
+real rayleigh_lcdf(vector, vector)
+real rayleigh_lcdf(vector, row_vector)
+real rayleigh_lcdf(vector, real[])
+real rayleigh_lcdf(row_vector, real)
+real rayleigh_lcdf(row_vector, vector)
+real rayleigh_lcdf(row_vector, row_vector)
+real rayleigh_lcdf(row_vector, real[])
+real rayleigh_lcdf(real[], vector)
+real rayleigh_lcdf(real[], row_vector)
+real rayleigh_log(real, vector)
+real rayleigh_log(real, row_vector)
+real rayleigh_log(vector, real)
+real rayleigh_log(vector, vector)
+real rayleigh_log(vector, row_vector)
+real rayleigh_log(vector, real[])
+real rayleigh_log(row_vector, real)
+real rayleigh_log(row_vector, vector)
+real rayleigh_log(row_vector, row_vector)
+real rayleigh_log(row_vector, real[])
+real rayleigh_log(real[], vector)
+real rayleigh_log(real[], row_vector)
+real rayleigh_lpdf(real, vector)
+real rayleigh_lpdf(real, row_vector)
+real rayleigh_lpdf(vector, real)
+real rayleigh_lpdf(vector, vector)
+real rayleigh_lpdf(vector, row_vector)
+real rayleigh_lpdf(vector, real[])
+real rayleigh_lpdf(row_vector, real)
+real rayleigh_lpdf(row_vector, vector)
+real rayleigh_lpdf(row_vector, row_vector)
+real rayleigh_lpdf(row_vector, real[])
+real rayleigh_lpdf(real[], vector)
+real rayleigh_lpdf(real[], row_vector)
+real[] rayleigh_rng(vector)
+real[] rayleigh_rng(row_vector)
+vector rows_dot_product(vector, vector)
+vector rows_dot_product(row_vector, row_vector)
+vector rows_dot_product(matrix, matrix)
+matrix scale_matrix_exp_multiply(real, matrix, matrix)
+real scaled_inv_chi_square_ccdf_log(real, real, vector)
+real scaled_inv_chi_square_ccdf_log(real, real, row_vector)
+real scaled_inv_chi_square_ccdf_log(real, vector, real)
+real scaled_inv_chi_square_ccdf_log(real, vector, vector)
+real scaled_inv_chi_square_ccdf_log(real, vector, row_vector)
+real scaled_inv_chi_square_ccdf_log(real, vector, real[])
+real scaled_inv_chi_square_ccdf_log(real, row_vector, real)
+real scaled_inv_chi_square_ccdf_log(real, row_vector, vector)
+real scaled_inv_chi_square_ccdf_log(real, row_vector, row_vector)
+real scaled_inv_chi_square_ccdf_log(real, row_vector, real[])
+real scaled_inv_chi_square_ccdf_log(real, real[], vector)
+real scaled_inv_chi_square_ccdf_log(real, real[], row_vector)
+real scaled_inv_chi_square_ccdf_log(vector, real, real)
+real scaled_inv_chi_square_ccdf_log(vector, real, vector)
+real scaled_inv_chi_square_ccdf_log(vector, real, row_vector)
+real scaled_inv_chi_square_ccdf_log(vector, real, real[])
+real scaled_inv_chi_square_ccdf_log(vector, vector, real)
+real scaled_inv_chi_square_ccdf_log(vector, vector, vector)
+real scaled_inv_chi_square_ccdf_log(vector, vector, row_vector)
+real scaled_inv_chi_square_ccdf_log(vector, vector, real[])
+real scaled_inv_chi_square_ccdf_log(vector, row_vector, real)
+real scaled_inv_chi_square_ccdf_log(vector, row_vector, vector)
+real scaled_inv_chi_square_ccdf_log(vector, row_vector, row_vector)
+real scaled_inv_chi_square_ccdf_log(vector, row_vector, real[])
+real scaled_inv_chi_square_ccdf_log(vector, real[], real)
+real scaled_inv_chi_square_ccdf_log(vector, real[], vector)
+real scaled_inv_chi_square_ccdf_log(vector, real[], row_vector)
+real scaled_inv_chi_square_ccdf_log(vector, real[], real[])
+real scaled_inv_chi_square_ccdf_log(row_vector, real, real)
+real scaled_inv_chi_square_ccdf_log(row_vector, real, vector)
+real scaled_inv_chi_square_ccdf_log(row_vector, real, row_vector)
+real scaled_inv_chi_square_ccdf_log(row_vector, real, real[])
+real scaled_inv_chi_square_ccdf_log(row_vector, vector, real)
+real scaled_inv_chi_square_ccdf_log(row_vector, vector, vector)
+real scaled_inv_chi_square_ccdf_log(row_vector, vector, row_vector)
+real scaled_inv_chi_square_ccdf_log(row_vector, vector, real[])
+real scaled_inv_chi_square_ccdf_log(row_vector, row_vector, real)
+real scaled_inv_chi_square_ccdf_log(row_vector, row_vector, vector)
+real scaled_inv_chi_square_ccdf_log(row_vector, row_vector, row_vector)
+real scaled_inv_chi_square_ccdf_log(row_vector, row_vector, real[])
+real scaled_inv_chi_square_ccdf_log(row_vector, real[], real)
+real scaled_inv_chi_square_ccdf_log(row_vector, real[], vector)
+real scaled_inv_chi_square_ccdf_log(row_vector, real[], row_vector)
+real scaled_inv_chi_square_ccdf_log(row_vector, real[], real[])
+real scaled_inv_chi_square_ccdf_log(real[], real, vector)
+real scaled_inv_chi_square_ccdf_log(real[], real, row_vector)
+real scaled_inv_chi_square_ccdf_log(real[], vector, real)
+real scaled_inv_chi_square_ccdf_log(real[], vector, vector)
+real scaled_inv_chi_square_ccdf_log(real[], vector, row_vector)
+real scaled_inv_chi_square_ccdf_log(real[], vector, real[])
+real scaled_inv_chi_square_ccdf_log(real[], row_vector, real)
+real scaled_inv_chi_square_ccdf_log(real[], row_vector, vector)
+real scaled_inv_chi_square_ccdf_log(real[], row_vector, row_vector)
+real scaled_inv_chi_square_ccdf_log(real[], row_vector, real[])
+real scaled_inv_chi_square_ccdf_log(real[], real[], vector)
+real scaled_inv_chi_square_ccdf_log(real[], real[], row_vector)
+real scaled_inv_chi_square_cdf(real, real, vector)
+real scaled_inv_chi_square_cdf(real, real, row_vector)
+real scaled_inv_chi_square_cdf(real, vector, real)
+real scaled_inv_chi_square_cdf(real, vector, vector)
+real scaled_inv_chi_square_cdf(real, vector, row_vector)
+real scaled_inv_chi_square_cdf(real, vector, real[])
+real scaled_inv_chi_square_cdf(real, row_vector, real)
+real scaled_inv_chi_square_cdf(real, row_vector, vector)
+real scaled_inv_chi_square_cdf(real, row_vector, row_vector)
+real scaled_inv_chi_square_cdf(real, row_vector, real[])
+real scaled_inv_chi_square_cdf(real, real[], vector)
+real scaled_inv_chi_square_cdf(real, real[], row_vector)
+real scaled_inv_chi_square_cdf(vector, real, real)
+real scaled_inv_chi_square_cdf(vector, real, vector)
+real scaled_inv_chi_square_cdf(vector, real, row_vector)
+real scaled_inv_chi_square_cdf(vector, real, real[])
+real scaled_inv_chi_square_cdf(vector, vector, real)
+real scaled_inv_chi_square_cdf(vector, vector, vector)
+real scaled_inv_chi_square_cdf(vector, vector, row_vector)
+real scaled_inv_chi_square_cdf(vector, vector, real[])
+real scaled_inv_chi_square_cdf(vector, row_vector, real)
+real scaled_inv_chi_square_cdf(vector, row_vector, vector)
+real scaled_inv_chi_square_cdf(vector, row_vector, row_vector)
+real scaled_inv_chi_square_cdf(vector, row_vector, real[])
+real scaled_inv_chi_square_cdf(vector, real[], real)
+real scaled_inv_chi_square_cdf(vector, real[], vector)
+real scaled_inv_chi_square_cdf(vector, real[], row_vector)
+real scaled_inv_chi_square_cdf(vector, real[], real[])
+real scaled_inv_chi_square_cdf(row_vector, real, real)
+real scaled_inv_chi_square_cdf(row_vector, real, vector)
+real scaled_inv_chi_square_cdf(row_vector, real, row_vector)
+real scaled_inv_chi_square_cdf(row_vector, real, real[])
+real scaled_inv_chi_square_cdf(row_vector, vector, real)
+real scaled_inv_chi_square_cdf(row_vector, vector, vector)
+real scaled_inv_chi_square_cdf(row_vector, vector, row_vector)
+real scaled_inv_chi_square_cdf(row_vector, vector, real[])
+real scaled_inv_chi_square_cdf(row_vector, row_vector, real)
+real scaled_inv_chi_square_cdf(row_vector, row_vector, vector)
+real scaled_inv_chi_square_cdf(row_vector, row_vector, row_vector)
+real scaled_inv_chi_square_cdf(row_vector, row_vector, real[])
+real scaled_inv_chi_square_cdf(row_vector, real[], real)
+real scaled_inv_chi_square_cdf(row_vector, real[], vector)
+real scaled_inv_chi_square_cdf(row_vector, real[], row_vector)
+real scaled_inv_chi_square_cdf(row_vector, real[], real[])
+real scaled_inv_chi_square_cdf(real[], real, vector)
+real scaled_inv_chi_square_cdf(real[], real, row_vector)
+real scaled_inv_chi_square_cdf(real[], vector, real)
+real scaled_inv_chi_square_cdf(real[], vector, vector)
+real scaled_inv_chi_square_cdf(real[], vector, row_vector)
+real scaled_inv_chi_square_cdf(real[], vector, real[])
+real scaled_inv_chi_square_cdf(real[], row_vector, real)
+real scaled_inv_chi_square_cdf(real[], row_vector, vector)
+real scaled_inv_chi_square_cdf(real[], row_vector, row_vector)
+real scaled_inv_chi_square_cdf(real[], row_vector, real[])
+real scaled_inv_chi_square_cdf(real[], real[], vector)
+real scaled_inv_chi_square_cdf(real[], real[], row_vector)
+real scaled_inv_chi_square_cdf_log(real, real, vector)
+real scaled_inv_chi_square_cdf_log(real, real, row_vector)
+real scaled_inv_chi_square_cdf_log(real, vector, real)
+real scaled_inv_chi_square_cdf_log(real, vector, vector)
+real scaled_inv_chi_square_cdf_log(real, vector, row_vector)
+real scaled_inv_chi_square_cdf_log(real, vector, real[])
+real scaled_inv_chi_square_cdf_log(real, row_vector, real)
+real scaled_inv_chi_square_cdf_log(real, row_vector, vector)
+real scaled_inv_chi_square_cdf_log(real, row_vector, row_vector)
+real scaled_inv_chi_square_cdf_log(real, row_vector, real[])
+real scaled_inv_chi_square_cdf_log(real, real[], vector)
+real scaled_inv_chi_square_cdf_log(real, real[], row_vector)
+real scaled_inv_chi_square_cdf_log(vector, real, real)
+real scaled_inv_chi_square_cdf_log(vector, real, vector)
+real scaled_inv_chi_square_cdf_log(vector, real, row_vector)
+real scaled_inv_chi_square_cdf_log(vector, real, real[])
+real scaled_inv_chi_square_cdf_log(vector, vector, real)
+real scaled_inv_chi_square_cdf_log(vector, vector, vector)
+real scaled_inv_chi_square_cdf_log(vector, vector, row_vector)
+real scaled_inv_chi_square_cdf_log(vector, vector, real[])
+real scaled_inv_chi_square_cdf_log(vector, row_vector, real)
+real scaled_inv_chi_square_cdf_log(vector, row_vector, vector)
+real scaled_inv_chi_square_cdf_log(vector, row_vector, row_vector)
+real scaled_inv_chi_square_cdf_log(vector, row_vector, real[])
+real scaled_inv_chi_square_cdf_log(vector, real[], real)
+real scaled_inv_chi_square_cdf_log(vector, real[], vector)
+real scaled_inv_chi_square_cdf_log(vector, real[], row_vector)
+real scaled_inv_chi_square_cdf_log(vector, real[], real[])
+real scaled_inv_chi_square_cdf_log(row_vector, real, real)
+real scaled_inv_chi_square_cdf_log(row_vector, real, vector)
+real scaled_inv_chi_square_cdf_log(row_vector, real, row_vector)
+real scaled_inv_chi_square_cdf_log(row_vector, real, real[])
+real scaled_inv_chi_square_cdf_log(row_vector, vector, real)
+real scaled_inv_chi_square_cdf_log(row_vector, vector, vector)
+real scaled_inv_chi_square_cdf_log(row_vector, vector, row_vector)
+real scaled_inv_chi_square_cdf_log(row_vector, vector, real[])
+real scaled_inv_chi_square_cdf_log(row_vector, row_vector, real)
+real scaled_inv_chi_square_cdf_log(row_vector, row_vector, vector)
+real scaled_inv_chi_square_cdf_log(row_vector, row_vector, row_vector)
+real scaled_inv_chi_square_cdf_log(row_vector, row_vector, real[])
+real scaled_inv_chi_square_cdf_log(row_vector, real[], real)
+real scaled_inv_chi_square_cdf_log(row_vector, real[], vector)
+real scaled_inv_chi_square_cdf_log(row_vector, real[], row_vector)
+real scaled_inv_chi_square_cdf_log(row_vector, real[], real[])
+real scaled_inv_chi_square_cdf_log(real[], real, vector)
+real scaled_inv_chi_square_cdf_log(real[], real, row_vector)
+real scaled_inv_chi_square_cdf_log(real[], vector, real)
+real scaled_inv_chi_square_cdf_log(real[], vector, vector)
+real scaled_inv_chi_square_cdf_log(real[], vector, row_vector)
+real scaled_inv_chi_square_cdf_log(real[], vector, real[])
+real scaled_inv_chi_square_cdf_log(real[], row_vector, real)
+real scaled_inv_chi_square_cdf_log(real[], row_vector, vector)
+real scaled_inv_chi_square_cdf_log(real[], row_vector, row_vector)
+real scaled_inv_chi_square_cdf_log(real[], row_vector, real[])
+real scaled_inv_chi_square_cdf_log(real[], real[], vector)
+real scaled_inv_chi_square_cdf_log(real[], real[], row_vector)
+real scaled_inv_chi_square_lccdf(real, real, vector)
+real scaled_inv_chi_square_lccdf(real, real, row_vector)
+real scaled_inv_chi_square_lccdf(real, vector, real)
+real scaled_inv_chi_square_lccdf(real, vector, vector)
+real scaled_inv_chi_square_lccdf(real, vector, row_vector)
+real scaled_inv_chi_square_lccdf(real, vector, real[])
+real scaled_inv_chi_square_lccdf(real, row_vector, real)
+real scaled_inv_chi_square_lccdf(real, row_vector, vector)
+real scaled_inv_chi_square_lccdf(real, row_vector, row_vector)
+real scaled_inv_chi_square_lccdf(real, row_vector, real[])
+real scaled_inv_chi_square_lccdf(real, real[], vector)
+real scaled_inv_chi_square_lccdf(real, real[], row_vector)
+real scaled_inv_chi_square_lccdf(vector, real, real)
+real scaled_inv_chi_square_lccdf(vector, real, vector)
+real scaled_inv_chi_square_lccdf(vector, real, row_vector)
+real scaled_inv_chi_square_lccdf(vector, real, real[])
+real scaled_inv_chi_square_lccdf(vector, vector, real)
+real scaled_inv_chi_square_lccdf(vector, vector, vector)
+real scaled_inv_chi_square_lccdf(vector, vector, row_vector)
+real scaled_inv_chi_square_lccdf(vector, vector, real[])
+real scaled_inv_chi_square_lccdf(vector, row_vector, real)
+real scaled_inv_chi_square_lccdf(vector, row_vector, vector)
+real scaled_inv_chi_square_lccdf(vector, row_vector, row_vector)
+real scaled_inv_chi_square_lccdf(vector, row_vector, real[])
+real scaled_inv_chi_square_lccdf(vector, real[], real)
+real scaled_inv_chi_square_lccdf(vector, real[], vector)
+real scaled_inv_chi_square_lccdf(vector, real[], row_vector)
+real scaled_inv_chi_square_lccdf(vector, real[], real[])
+real scaled_inv_chi_square_lccdf(row_vector, real, real)
+real scaled_inv_chi_square_lccdf(row_vector, real, vector)
+real scaled_inv_chi_square_lccdf(row_vector, real, row_vector)
+real scaled_inv_chi_square_lccdf(row_vector, real, real[])
+real scaled_inv_chi_square_lccdf(row_vector, vector, real)
+real scaled_inv_chi_square_lccdf(row_vector, vector, vector)
+real scaled_inv_chi_square_lccdf(row_vector, vector, row_vector)
+real scaled_inv_chi_square_lccdf(row_vector, vector, real[])
+real scaled_inv_chi_square_lccdf(row_vector, row_vector, real)
+real scaled_inv_chi_square_lccdf(row_vector, row_vector, vector)
+real scaled_inv_chi_square_lccdf(row_vector, row_vector, row_vector)
+real scaled_inv_chi_square_lccdf(row_vector, row_vector, real[])
+real scaled_inv_chi_square_lccdf(row_vector, real[], real)
+real scaled_inv_chi_square_lccdf(row_vector, real[], vector)
+real scaled_inv_chi_square_lccdf(row_vector, real[], row_vector)
+real scaled_inv_chi_square_lccdf(row_vector, real[], real[])
+real scaled_inv_chi_square_lccdf(real[], real, vector)
+real scaled_inv_chi_square_lccdf(real[], real, row_vector)
+real scaled_inv_chi_square_lccdf(real[], vector, real)
+real scaled_inv_chi_square_lccdf(real[], vector, vector)
+real scaled_inv_chi_square_lccdf(real[], vector, row_vector)
+real scaled_inv_chi_square_lccdf(real[], vector, real[])
+real scaled_inv_chi_square_lccdf(real[], row_vector, real)
+real scaled_inv_chi_square_lccdf(real[], row_vector, vector)
+real scaled_inv_chi_square_lccdf(real[], row_vector, row_vector)
+real scaled_inv_chi_square_lccdf(real[], row_vector, real[])
+real scaled_inv_chi_square_lccdf(real[], real[], vector)
+real scaled_inv_chi_square_lccdf(real[], real[], row_vector)
+real scaled_inv_chi_square_lcdf(real, real, vector)
+real scaled_inv_chi_square_lcdf(real, real, row_vector)
+real scaled_inv_chi_square_lcdf(real, vector, real)
+real scaled_inv_chi_square_lcdf(real, vector, vector)
+real scaled_inv_chi_square_lcdf(real, vector, row_vector)
+real scaled_inv_chi_square_lcdf(real, vector, real[])
+real scaled_inv_chi_square_lcdf(real, row_vector, real)
+real scaled_inv_chi_square_lcdf(real, row_vector, vector)
+real scaled_inv_chi_square_lcdf(real, row_vector, row_vector)
+real scaled_inv_chi_square_lcdf(real, row_vector, real[])
+real scaled_inv_chi_square_lcdf(real, real[], vector)
+real scaled_inv_chi_square_lcdf(real, real[], row_vector)
+real scaled_inv_chi_square_lcdf(vector, real, real)
+real scaled_inv_chi_square_lcdf(vector, real, vector)
+real scaled_inv_chi_square_lcdf(vector, real, row_vector)
+real scaled_inv_chi_square_lcdf(vector, real, real[])
+real scaled_inv_chi_square_lcdf(vector, vector, real)
+real scaled_inv_chi_square_lcdf(vector, vector, vector)
+real scaled_inv_chi_square_lcdf(vector, vector, row_vector)
+real scaled_inv_chi_square_lcdf(vector, vector, real[])
+real scaled_inv_chi_square_lcdf(vector, row_vector, real)
+real scaled_inv_chi_square_lcdf(vector, row_vector, vector)
+real scaled_inv_chi_square_lcdf(vector, row_vector, row_vector)
+real scaled_inv_chi_square_lcdf(vector, row_vector, real[])
+real scaled_inv_chi_square_lcdf(vector, real[], real)
+real scaled_inv_chi_square_lcdf(vector, real[], vector)
+real scaled_inv_chi_square_lcdf(vector, real[], row_vector)
+real scaled_inv_chi_square_lcdf(vector, real[], real[])
+real scaled_inv_chi_square_lcdf(row_vector, real, real)
+real scaled_inv_chi_square_lcdf(row_vector, real, vector)
+real scaled_inv_chi_square_lcdf(row_vector, real, row_vector)
+real scaled_inv_chi_square_lcdf(row_vector, real, real[])
+real scaled_inv_chi_square_lcdf(row_vector, vector, real)
+real scaled_inv_chi_square_lcdf(row_vector, vector, vector)
+real scaled_inv_chi_square_lcdf(row_vector, vector, row_vector)
+real scaled_inv_chi_square_lcdf(row_vector, vector, real[])
+real scaled_inv_chi_square_lcdf(row_vector, row_vector, real)
+real scaled_inv_chi_square_lcdf(row_vector, row_vector, vector)
+real scaled_inv_chi_square_lcdf(row_vector, row_vector, row_vector)
+real scaled_inv_chi_square_lcdf(row_vector, row_vector, real[])
+real scaled_inv_chi_square_lcdf(row_vector, real[], real)
+real scaled_inv_chi_square_lcdf(row_vector, real[], vector)
+real scaled_inv_chi_square_lcdf(row_vector, real[], row_vector)
+real scaled_inv_chi_square_lcdf(row_vector, real[], real[])
+real scaled_inv_chi_square_lcdf(real[], real, vector)
+real scaled_inv_chi_square_lcdf(real[], real, row_vector)
+real scaled_inv_chi_square_lcdf(real[], vector, real)
+real scaled_inv_chi_square_lcdf(real[], vector, vector)
+real scaled_inv_chi_square_lcdf(real[], vector, row_vector)
+real scaled_inv_chi_square_lcdf(real[], vector, real[])
+real scaled_inv_chi_square_lcdf(real[], row_vector, real)
+real scaled_inv_chi_square_lcdf(real[], row_vector, vector)
+real scaled_inv_chi_square_lcdf(real[], row_vector, row_vector)
+real scaled_inv_chi_square_lcdf(real[], row_vector, real[])
+real scaled_inv_chi_square_lcdf(real[], real[], vector)
+real scaled_inv_chi_square_lcdf(real[], real[], row_vector)
+real scaled_inv_chi_square_log(real, real, vector)
+real scaled_inv_chi_square_log(real, real, row_vector)
+real scaled_inv_chi_square_log(real, vector, real)
+real scaled_inv_chi_square_log(real, vector, vector)
+real scaled_inv_chi_square_log(real, vector, row_vector)
+real scaled_inv_chi_square_log(real, vector, real[])
+real scaled_inv_chi_square_log(real, row_vector, real)
+real scaled_inv_chi_square_log(real, row_vector, vector)
+real scaled_inv_chi_square_log(real, row_vector, row_vector)
+real scaled_inv_chi_square_log(real, row_vector, real[])
+real scaled_inv_chi_square_log(real, real[], vector)
+real scaled_inv_chi_square_log(real, real[], row_vector)
+real scaled_inv_chi_square_log(vector, real, real)
+real scaled_inv_chi_square_log(vector, real, vector)
+real scaled_inv_chi_square_log(vector, real, row_vector)
+real scaled_inv_chi_square_log(vector, real, real[])
+real scaled_inv_chi_square_log(vector, vector, real)
+real scaled_inv_chi_square_log(vector, vector, vector)
+real scaled_inv_chi_square_log(vector, vector, row_vector)
+real scaled_inv_chi_square_log(vector, vector, real[])
+real scaled_inv_chi_square_log(vector, row_vector, real)
+real scaled_inv_chi_square_log(vector, row_vector, vector)
+real scaled_inv_chi_square_log(vector, row_vector, row_vector)
+real scaled_inv_chi_square_log(vector, row_vector, real[])
+real scaled_inv_chi_square_log(vector, real[], real)
+real scaled_inv_chi_square_log(vector, real[], vector)
+real scaled_inv_chi_square_log(vector, real[], row_vector)
+real scaled_inv_chi_square_log(vector, real[], real[])
+real scaled_inv_chi_square_log(row_vector, real, real)
+real scaled_inv_chi_square_log(row_vector, real, vector)
+real scaled_inv_chi_square_log(row_vector, real, row_vector)
+real scaled_inv_chi_square_log(row_vector, real, real[])
+real scaled_inv_chi_square_log(row_vector, vector, real)
+real scaled_inv_chi_square_log(row_vector, vector, vector)
+real scaled_inv_chi_square_log(row_vector, vector, row_vector)
+real scaled_inv_chi_square_log(row_vector, vector, real[])
+real scaled_inv_chi_square_log(row_vector, row_vector, real)
+real scaled_inv_chi_square_log(row_vector, row_vector, vector)
+real scaled_inv_chi_square_log(row_vector, row_vector, row_vector)
+real scaled_inv_chi_square_log(row_vector, row_vector, real[])
+real scaled_inv_chi_square_log(row_vector, real[], real)
+real scaled_inv_chi_square_log(row_vector, real[], vector)
+real scaled_inv_chi_square_log(row_vector, real[], row_vector)
+real scaled_inv_chi_square_log(row_vector, real[], real[])
+real scaled_inv_chi_square_log(real[], real, vector)
+real scaled_inv_chi_square_log(real[], real, row_vector)
+real scaled_inv_chi_square_log(real[], vector, real)
+real scaled_inv_chi_square_log(real[], vector, vector)
+real scaled_inv_chi_square_log(real[], vector, row_vector)
+real scaled_inv_chi_square_log(real[], vector, real[])
+real scaled_inv_chi_square_log(real[], row_vector, real)
+real scaled_inv_chi_square_log(real[], row_vector, vector)
+real scaled_inv_chi_square_log(real[], row_vector, row_vector)
+real scaled_inv_chi_square_log(real[], row_vector, real[])
+real scaled_inv_chi_square_log(real[], real[], vector)
+real scaled_inv_chi_square_log(real[], real[], row_vector)
+real scaled_inv_chi_square_lpdf(real, real, vector)
+real scaled_inv_chi_square_lpdf(real, real, row_vector)
+real scaled_inv_chi_square_lpdf(real, vector, real)
+real scaled_inv_chi_square_lpdf(real, vector, vector)
+real scaled_inv_chi_square_lpdf(real, vector, row_vector)
+real scaled_inv_chi_square_lpdf(real, vector, real[])
+real scaled_inv_chi_square_lpdf(real, row_vector, real)
+real scaled_inv_chi_square_lpdf(real, row_vector, vector)
+real scaled_inv_chi_square_lpdf(real, row_vector, row_vector)
+real scaled_inv_chi_square_lpdf(real, row_vector, real[])
+real scaled_inv_chi_square_lpdf(real, real[], vector)
+real scaled_inv_chi_square_lpdf(real, real[], row_vector)
+real scaled_inv_chi_square_lpdf(vector, real, real)
+real scaled_inv_chi_square_lpdf(vector, real, vector)
+real scaled_inv_chi_square_lpdf(vector, real, row_vector)
+real scaled_inv_chi_square_lpdf(vector, real, real[])
+real scaled_inv_chi_square_lpdf(vector, vector, real)
+real scaled_inv_chi_square_lpdf(vector, vector, vector)
+real scaled_inv_chi_square_lpdf(vector, vector, row_vector)
+real scaled_inv_chi_square_lpdf(vector, vector, real[])
+real scaled_inv_chi_square_lpdf(vector, row_vector, real)
+real scaled_inv_chi_square_lpdf(vector, row_vector, vector)
+real scaled_inv_chi_square_lpdf(vector, row_vector, row_vector)
+real scaled_inv_chi_square_lpdf(vector, row_vector, real[])
+real scaled_inv_chi_square_lpdf(vector, real[], real)
+real scaled_inv_chi_square_lpdf(vector, real[], vector)
+real scaled_inv_chi_square_lpdf(vector, real[], row_vector)
+real scaled_inv_chi_square_lpdf(vector, real[], real[])
+real scaled_inv_chi_square_lpdf(row_vector, real, real)
+real scaled_inv_chi_square_lpdf(row_vector, real, vector)
+real scaled_inv_chi_square_lpdf(row_vector, real, row_vector)
+real scaled_inv_chi_square_lpdf(row_vector, real, real[])
+real scaled_inv_chi_square_lpdf(row_vector, vector, real)
+real scaled_inv_chi_square_lpdf(row_vector, vector, vector)
+real scaled_inv_chi_square_lpdf(row_vector, vector, row_vector)
+real scaled_inv_chi_square_lpdf(row_vector, vector, real[])
+real scaled_inv_chi_square_lpdf(row_vector, row_vector, real)
+real scaled_inv_chi_square_lpdf(row_vector, row_vector, vector)
+real scaled_inv_chi_square_lpdf(row_vector, row_vector, row_vector)
+real scaled_inv_chi_square_lpdf(row_vector, row_vector, real[])
+real scaled_inv_chi_square_lpdf(row_vector, real[], real)
+real scaled_inv_chi_square_lpdf(row_vector, real[], vector)
+real scaled_inv_chi_square_lpdf(row_vector, real[], row_vector)
+real scaled_inv_chi_square_lpdf(row_vector, real[], real[])
+real scaled_inv_chi_square_lpdf(real[], real, vector)
+real scaled_inv_chi_square_lpdf(real[], real, row_vector)
+real scaled_inv_chi_square_lpdf(real[], vector, real)
+real scaled_inv_chi_square_lpdf(real[], vector, vector)
+real scaled_inv_chi_square_lpdf(real[], vector, row_vector)
+real scaled_inv_chi_square_lpdf(real[], vector, real[])
+real scaled_inv_chi_square_lpdf(real[], row_vector, real)
+real scaled_inv_chi_square_lpdf(real[], row_vector, vector)
+real scaled_inv_chi_square_lpdf(real[], row_vector, row_vector)
+real scaled_inv_chi_square_lpdf(real[], row_vector, real[])
+real scaled_inv_chi_square_lpdf(real[], real[], vector)
+real scaled_inv_chi_square_lpdf(real[], real[], row_vector)
+real[] scaled_inv_chi_square_rng(int, vector)
+real[] scaled_inv_chi_square_rng(int, row_vector)
+real[] scaled_inv_chi_square_rng(real, vector)
+real[] scaled_inv_chi_square_rng(real, row_vector)
+real[] scaled_inv_chi_square_rng(vector, int)
+real[] scaled_inv_chi_square_rng(vector, real)
+real[] scaled_inv_chi_square_rng(vector, vector)
+real[] scaled_inv_chi_square_rng(vector, row_vector)
+real[] scaled_inv_chi_square_rng(vector, int[])
+real[] scaled_inv_chi_square_rng(vector, real[])
+real[] scaled_inv_chi_square_rng(row_vector, int)
+real[] scaled_inv_chi_square_rng(row_vector, real)
+real[] scaled_inv_chi_square_rng(row_vector, vector)
+real[] scaled_inv_chi_square_rng(row_vector, row_vector)
+real[] scaled_inv_chi_square_rng(row_vector, int[])
+real[] scaled_inv_chi_square_rng(row_vector, real[])
+real[] scaled_inv_chi_square_rng(int[], vector)
+real[] scaled_inv_chi_square_rng(int[], row_vector)
+real[] scaled_inv_chi_square_rng(real[], vector)
+real[] scaled_inv_chi_square_rng(real[], row_vector)
+real sd(vector)
+real sd(row_vector)
+real sd(matrix)
+real skew_normal_ccdf_log(real, real, real, vector)
+real skew_normal_ccdf_log(real, real, real, row_vector)
+real skew_normal_ccdf_log(real, real, vector, real)
+real skew_normal_ccdf_log(real, real, vector, vector)
+real skew_normal_ccdf_log(real, real, vector, row_vector)
+real skew_normal_ccdf_log(real, real, vector, real[])
+real skew_normal_ccdf_log(real, real, row_vector, real)
+real skew_normal_ccdf_log(real, real, row_vector, vector)
+real skew_normal_ccdf_log(real, real, row_vector, row_vector)
+real skew_normal_ccdf_log(real, real, row_vector, real[])
+real skew_normal_ccdf_log(real, real, real[], vector)
+real skew_normal_ccdf_log(real, real, real[], row_vector)
+real skew_normal_ccdf_log(real, vector, real, real)
+real skew_normal_ccdf_log(real, vector, real, vector)
+real skew_normal_ccdf_log(real, vector, real, row_vector)
+real skew_normal_ccdf_log(real, vector, real, real[])
+real skew_normal_ccdf_log(real, vector, vector, real)
+real skew_normal_ccdf_log(real, vector, vector, vector)
+real skew_normal_ccdf_log(real, vector, vector, row_vector)
+real skew_normal_ccdf_log(real, vector, vector, real[])
+real skew_normal_ccdf_log(real, vector, row_vector, real)
+real skew_normal_ccdf_log(real, vector, row_vector, vector)
+real skew_normal_ccdf_log(real, vector, row_vector, row_vector)
+real skew_normal_ccdf_log(real, vector, row_vector, real[])
+real skew_normal_ccdf_log(real, vector, real[], real)
+real skew_normal_ccdf_log(real, vector, real[], vector)
+real skew_normal_ccdf_log(real, vector, real[], row_vector)
+real skew_normal_ccdf_log(real, vector, real[], real[])
+real skew_normal_ccdf_log(real, row_vector, real, real)
+real skew_normal_ccdf_log(real, row_vector, real, vector)
+real skew_normal_ccdf_log(real, row_vector, real, row_vector)
+real skew_normal_ccdf_log(real, row_vector, real, real[])
+real skew_normal_ccdf_log(real, row_vector, vector, real)
+real skew_normal_ccdf_log(real, row_vector, vector, vector)
+real skew_normal_ccdf_log(real, row_vector, vector, row_vector)
+real skew_normal_ccdf_log(real, row_vector, vector, real[])
+real skew_normal_ccdf_log(real, row_vector, row_vector, real)
+real skew_normal_ccdf_log(real, row_vector, row_vector, vector)
+real skew_normal_ccdf_log(real, row_vector, row_vector, row_vector)
+real skew_normal_ccdf_log(real, row_vector, row_vector, real[])
+real skew_normal_ccdf_log(real, row_vector, real[], real)
+real skew_normal_ccdf_log(real, row_vector, real[], vector)
+real skew_normal_ccdf_log(real, row_vector, real[], row_vector)
+real skew_normal_ccdf_log(real, row_vector, real[], real[])
+real skew_normal_ccdf_log(real, real[], real, vector)
+real skew_normal_ccdf_log(real, real[], real, row_vector)
+real skew_normal_ccdf_log(real, real[], vector, real)
+real skew_normal_ccdf_log(real, real[], vector, vector)
+real skew_normal_ccdf_log(real, real[], vector, row_vector)
+real skew_normal_ccdf_log(real, real[], vector, real[])
+real skew_normal_ccdf_log(real, real[], row_vector, real)
+real skew_normal_ccdf_log(real, real[], row_vector, vector)
+real skew_normal_ccdf_log(real, real[], row_vector, row_vector)
+real skew_normal_ccdf_log(real, real[], row_vector, real[])
+real skew_normal_ccdf_log(real, real[], real[], vector)
+real skew_normal_ccdf_log(real, real[], real[], row_vector)
+real skew_normal_ccdf_log(vector, real, real, real)
+real skew_normal_ccdf_log(vector, real, real, vector)
+real skew_normal_ccdf_log(vector, real, real, row_vector)
+real skew_normal_ccdf_log(vector, real, real, real[])
+real skew_normal_ccdf_log(vector, real, vector, real)
+real skew_normal_ccdf_log(vector, real, vector, vector)
+real skew_normal_ccdf_log(vector, real, vector, row_vector)
+real skew_normal_ccdf_log(vector, real, vector, real[])
+real skew_normal_ccdf_log(vector, real, row_vector, real)
+real skew_normal_ccdf_log(vector, real, row_vector, vector)
+real skew_normal_ccdf_log(vector, real, row_vector, row_vector)
+real skew_normal_ccdf_log(vector, real, row_vector, real[])
+real skew_normal_ccdf_log(vector, real, real[], real)
+real skew_normal_ccdf_log(vector, real, real[], vector)
+real skew_normal_ccdf_log(vector, real, real[], row_vector)
+real skew_normal_ccdf_log(vector, real, real[], real[])
+real skew_normal_ccdf_log(vector, vector, real, real)
+real skew_normal_ccdf_log(vector, vector, real, vector)
+real skew_normal_ccdf_log(vector, vector, real, row_vector)
+real skew_normal_ccdf_log(vector, vector, real, real[])
+real skew_normal_ccdf_log(vector, vector, vector, real)
+real skew_normal_ccdf_log(vector, vector, vector, vector)
+real skew_normal_ccdf_log(vector, vector, vector, row_vector)
+real skew_normal_ccdf_log(vector, vector, vector, real[])
+real skew_normal_ccdf_log(vector, vector, row_vector, real)
+real skew_normal_ccdf_log(vector, vector, row_vector, vector)
+real skew_normal_ccdf_log(vector, vector, row_vector, row_vector)
+real skew_normal_ccdf_log(vector, vector, row_vector, real[])
+real skew_normal_ccdf_log(vector, vector, real[], real)
+real skew_normal_ccdf_log(vector, vector, real[], vector)
+real skew_normal_ccdf_log(vector, vector, real[], row_vector)
+real skew_normal_ccdf_log(vector, vector, real[], real[])
+real skew_normal_ccdf_log(vector, row_vector, real, real)
+real skew_normal_ccdf_log(vector, row_vector, real, vector)
+real skew_normal_ccdf_log(vector, row_vector, real, row_vector)
+real skew_normal_ccdf_log(vector, row_vector, real, real[])
+real skew_normal_ccdf_log(vector, row_vector, vector, real)
+real skew_normal_ccdf_log(vector, row_vector, vector, vector)
+real skew_normal_ccdf_log(vector, row_vector, vector, row_vector)
+real skew_normal_ccdf_log(vector, row_vector, vector, real[])
+real skew_normal_ccdf_log(vector, row_vector, row_vector, real)
+real skew_normal_ccdf_log(vector, row_vector, row_vector, vector)
+real skew_normal_ccdf_log(vector, row_vector, row_vector, row_vector)
+real skew_normal_ccdf_log(vector, row_vector, row_vector, real[])
+real skew_normal_ccdf_log(vector, row_vector, real[], real)
+real skew_normal_ccdf_log(vector, row_vector, real[], vector)
+real skew_normal_ccdf_log(vector, row_vector, real[], row_vector)
+real skew_normal_ccdf_log(vector, row_vector, real[], real[])
+real skew_normal_ccdf_log(vector, real[], real, real)
+real skew_normal_ccdf_log(vector, real[], real, vector)
+real skew_normal_ccdf_log(vector, real[], real, row_vector)
+real skew_normal_ccdf_log(vector, real[], real, real[])
+real skew_normal_ccdf_log(vector, real[], vector, real)
+real skew_normal_ccdf_log(vector, real[], vector, vector)
+real skew_normal_ccdf_log(vector, real[], vector, row_vector)
+real skew_normal_ccdf_log(vector, real[], vector, real[])
+real skew_normal_ccdf_log(vector, real[], row_vector, real)
+real skew_normal_ccdf_log(vector, real[], row_vector, vector)
+real skew_normal_ccdf_log(vector, real[], row_vector, row_vector)
+real skew_normal_ccdf_log(vector, real[], row_vector, real[])
+real skew_normal_ccdf_log(vector, real[], real[], real)
+real skew_normal_ccdf_log(vector, real[], real[], vector)
+real skew_normal_ccdf_log(vector, real[], real[], row_vector)
+real skew_normal_ccdf_log(vector, real[], real[], real[])
+real skew_normal_ccdf_log(row_vector, real, real, real)
+real skew_normal_ccdf_log(row_vector, real, real, vector)
+real skew_normal_ccdf_log(row_vector, real, real, row_vector)
+real skew_normal_ccdf_log(row_vector, real, real, real[])
+real skew_normal_ccdf_log(row_vector, real, vector, real)
+real skew_normal_ccdf_log(row_vector, real, vector, vector)
+real skew_normal_ccdf_log(row_vector, real, vector, row_vector)
+real skew_normal_ccdf_log(row_vector, real, vector, real[])
+real skew_normal_ccdf_log(row_vector, real, row_vector, real)
+real skew_normal_ccdf_log(row_vector, real, row_vector, vector)
+real skew_normal_ccdf_log(row_vector, real, row_vector, row_vector)
+real skew_normal_ccdf_log(row_vector, real, row_vector, real[])
+real skew_normal_ccdf_log(row_vector, real, real[], real)
+real skew_normal_ccdf_log(row_vector, real, real[], vector)
+real skew_normal_ccdf_log(row_vector, real, real[], row_vector)
+real skew_normal_ccdf_log(row_vector, real, real[], real[])
+real skew_normal_ccdf_log(row_vector, vector, real, real)
+real skew_normal_ccdf_log(row_vector, vector, real, vector)
+real skew_normal_ccdf_log(row_vector, vector, real, row_vector)
+real skew_normal_ccdf_log(row_vector, vector, real, real[])
+real skew_normal_ccdf_log(row_vector, vector, vector, real)
+real skew_normal_ccdf_log(row_vector, vector, vector, vector)
+real skew_normal_ccdf_log(row_vector, vector, vector, row_vector)
+real skew_normal_ccdf_log(row_vector, vector, vector, real[])
+real skew_normal_ccdf_log(row_vector, vector, row_vector, real)
+real skew_normal_ccdf_log(row_vector, vector, row_vector, vector)
+real skew_normal_ccdf_log(row_vector, vector, row_vector, row_vector)
+real skew_normal_ccdf_log(row_vector, vector, row_vector, real[])
+real skew_normal_ccdf_log(row_vector, vector, real[], real)
+real skew_normal_ccdf_log(row_vector, vector, real[], vector)
+real skew_normal_ccdf_log(row_vector, vector, real[], row_vector)
+real skew_normal_ccdf_log(row_vector, vector, real[], real[])
+real skew_normal_ccdf_log(row_vector, row_vector, real, real)
+real skew_normal_ccdf_log(row_vector, row_vector, real, vector)
+real skew_normal_ccdf_log(row_vector, row_vector, real, row_vector)
+real skew_normal_ccdf_log(row_vector, row_vector, real, real[])
+real skew_normal_ccdf_log(row_vector, row_vector, vector, real)
+real skew_normal_ccdf_log(row_vector, row_vector, vector, vector)
+real skew_normal_ccdf_log(row_vector, row_vector, vector, row_vector)
+real skew_normal_ccdf_log(row_vector, row_vector, vector, real[])
+real skew_normal_ccdf_log(row_vector, row_vector, row_vector, real)
+real skew_normal_ccdf_log(row_vector, row_vector, row_vector, vector)
+real skew_normal_ccdf_log(row_vector, row_vector, row_vector, row_vector)
+real skew_normal_ccdf_log(row_vector, row_vector, row_vector, real[])
+real skew_normal_ccdf_log(row_vector, row_vector, real[], real)
+real skew_normal_ccdf_log(row_vector, row_vector, real[], vector)
+real skew_normal_ccdf_log(row_vector, row_vector, real[], row_vector)
+real skew_normal_ccdf_log(row_vector, row_vector, real[], real[])
+real skew_normal_ccdf_log(row_vector, real[], real, real)
+real skew_normal_ccdf_log(row_vector, real[], real, vector)
+real skew_normal_ccdf_log(row_vector, real[], real, row_vector)
+real skew_normal_ccdf_log(row_vector, real[], real, real[])
+real skew_normal_ccdf_log(row_vector, real[], vector, real)
+real skew_normal_ccdf_log(row_vector, real[], vector, vector)
+real skew_normal_ccdf_log(row_vector, real[], vector, row_vector)
+real skew_normal_ccdf_log(row_vector, real[], vector, real[])
+real skew_normal_ccdf_log(row_vector, real[], row_vector, real)
+real skew_normal_ccdf_log(row_vector, real[], row_vector, vector)
+real skew_normal_ccdf_log(row_vector, real[], row_vector, row_vector)
+real skew_normal_ccdf_log(row_vector, real[], row_vector, real[])
+real skew_normal_ccdf_log(row_vector, real[], real[], real)
+real skew_normal_ccdf_log(row_vector, real[], real[], vector)
+real skew_normal_ccdf_log(row_vector, real[], real[], row_vector)
+real skew_normal_ccdf_log(row_vector, real[], real[], real[])
+real skew_normal_ccdf_log(real[], real, real, vector)
+real skew_normal_ccdf_log(real[], real, real, row_vector)
+real skew_normal_ccdf_log(real[], real, vector, real)
+real skew_normal_ccdf_log(real[], real, vector, vector)
+real skew_normal_ccdf_log(real[], real, vector, row_vector)
+real skew_normal_ccdf_log(real[], real, vector, real[])
+real skew_normal_ccdf_log(real[], real, row_vector, real)
+real skew_normal_ccdf_log(real[], real, row_vector, vector)
+real skew_normal_ccdf_log(real[], real, row_vector, row_vector)
+real skew_normal_ccdf_log(real[], real, row_vector, real[])
+real skew_normal_ccdf_log(real[], real, real[], vector)
+real skew_normal_ccdf_log(real[], real, real[], row_vector)
+real skew_normal_ccdf_log(real[], vector, real, real)
+real skew_normal_ccdf_log(real[], vector, real, vector)
+real skew_normal_ccdf_log(real[], vector, real, row_vector)
+real skew_normal_ccdf_log(real[], vector, real, real[])
+real skew_normal_ccdf_log(real[], vector, vector, real)
+real skew_normal_ccdf_log(real[], vector, vector, vector)
+real skew_normal_ccdf_log(real[], vector, vector, row_vector)
+real skew_normal_ccdf_log(real[], vector, vector, real[])
+real skew_normal_ccdf_log(real[], vector, row_vector, real)
+real skew_normal_ccdf_log(real[], vector, row_vector, vector)
+real skew_normal_ccdf_log(real[], vector, row_vector, row_vector)
+real skew_normal_ccdf_log(real[], vector, row_vector, real[])
+real skew_normal_ccdf_log(real[], vector, real[], real)
+real skew_normal_ccdf_log(real[], vector, real[], vector)
+real skew_normal_ccdf_log(real[], vector, real[], row_vector)
+real skew_normal_ccdf_log(real[], vector, real[], real[])
+real skew_normal_ccdf_log(real[], row_vector, real, real)
+real skew_normal_ccdf_log(real[], row_vector, real, vector)
+real skew_normal_ccdf_log(real[], row_vector, real, row_vector)
+real skew_normal_ccdf_log(real[], row_vector, real, real[])
+real skew_normal_ccdf_log(real[], row_vector, vector, real)
+real skew_normal_ccdf_log(real[], row_vector, vector, vector)
+real skew_normal_ccdf_log(real[], row_vector, vector, row_vector)
+real skew_normal_ccdf_log(real[], row_vector, vector, real[])
+real skew_normal_ccdf_log(real[], row_vector, row_vector, real)
+real skew_normal_ccdf_log(real[], row_vector, row_vector, vector)
+real skew_normal_ccdf_log(real[], row_vector, row_vector, row_vector)
+real skew_normal_ccdf_log(real[], row_vector, row_vector, real[])
+real skew_normal_ccdf_log(real[], row_vector, real[], real)
+real skew_normal_ccdf_log(real[], row_vector, real[], vector)
+real skew_normal_ccdf_log(real[], row_vector, real[], row_vector)
+real skew_normal_ccdf_log(real[], row_vector, real[], real[])
+real skew_normal_ccdf_log(real[], real[], real, vector)
+real skew_normal_ccdf_log(real[], real[], real, row_vector)
+real skew_normal_ccdf_log(real[], real[], vector, real)
+real skew_normal_ccdf_log(real[], real[], vector, vector)
+real skew_normal_ccdf_log(real[], real[], vector, row_vector)
+real skew_normal_ccdf_log(real[], real[], vector, real[])
+real skew_normal_ccdf_log(real[], real[], row_vector, real)
+real skew_normal_ccdf_log(real[], real[], row_vector, vector)
+real skew_normal_ccdf_log(real[], real[], row_vector, row_vector)
+real skew_normal_ccdf_log(real[], real[], row_vector, real[])
+real skew_normal_ccdf_log(real[], real[], real[], vector)
+real skew_normal_ccdf_log(real[], real[], real[], row_vector)
+real skew_normal_cdf(real, real, real, vector)
+real skew_normal_cdf(real, real, real, row_vector)
+real skew_normal_cdf(real, real, vector, real)
+real skew_normal_cdf(real, real, vector, vector)
+real skew_normal_cdf(real, real, vector, row_vector)
+real skew_normal_cdf(real, real, vector, real[])
+real skew_normal_cdf(real, real, row_vector, real)
+real skew_normal_cdf(real, real, row_vector, vector)
+real skew_normal_cdf(real, real, row_vector, row_vector)
+real skew_normal_cdf(real, real, row_vector, real[])
+real skew_normal_cdf(real, real, real[], vector)
+real skew_normal_cdf(real, real, real[], row_vector)
+real skew_normal_cdf(real, vector, real, real)
+real skew_normal_cdf(real, vector, real, vector)
+real skew_normal_cdf(real, vector, real, row_vector)
+real skew_normal_cdf(real, vector, real, real[])
+real skew_normal_cdf(real, vector, vector, real)
+real skew_normal_cdf(real, vector, vector, vector)
+real skew_normal_cdf(real, vector, vector, row_vector)
+real skew_normal_cdf(real, vector, vector, real[])
+real skew_normal_cdf(real, vector, row_vector, real)
+real skew_normal_cdf(real, vector, row_vector, vector)
+real skew_normal_cdf(real, vector, row_vector, row_vector)
+real skew_normal_cdf(real, vector, row_vector, real[])
+real skew_normal_cdf(real, vector, real[], real)
+real skew_normal_cdf(real, vector, real[], vector)
+real skew_normal_cdf(real, vector, real[], row_vector)
+real skew_normal_cdf(real, vector, real[], real[])
+real skew_normal_cdf(real, row_vector, real, real)
+real skew_normal_cdf(real, row_vector, real, vector)
+real skew_normal_cdf(real, row_vector, real, row_vector)
+real skew_normal_cdf(real, row_vector, real, real[])
+real skew_normal_cdf(real, row_vector, vector, real)
+real skew_normal_cdf(real, row_vector, vector, vector)
+real skew_normal_cdf(real, row_vector, vector, row_vector)
+real skew_normal_cdf(real, row_vector, vector, real[])
+real skew_normal_cdf(real, row_vector, row_vector, real)
+real skew_normal_cdf(real, row_vector, row_vector, vector)
+real skew_normal_cdf(real, row_vector, row_vector, row_vector)
+real skew_normal_cdf(real, row_vector, row_vector, real[])
+real skew_normal_cdf(real, row_vector, real[], real)
+real skew_normal_cdf(real, row_vector, real[], vector)
+real skew_normal_cdf(real, row_vector, real[], row_vector)
+real skew_normal_cdf(real, row_vector, real[], real[])
+real skew_normal_cdf(real, real[], real, vector)
+real skew_normal_cdf(real, real[], real, row_vector)
+real skew_normal_cdf(real, real[], vector, real)
+real skew_normal_cdf(real, real[], vector, vector)
+real skew_normal_cdf(real, real[], vector, row_vector)
+real skew_normal_cdf(real, real[], vector, real[])
+real skew_normal_cdf(real, real[], row_vector, real)
+real skew_normal_cdf(real, real[], row_vector, vector)
+real skew_normal_cdf(real, real[], row_vector, row_vector)
+real skew_normal_cdf(real, real[], row_vector, real[])
+real skew_normal_cdf(real, real[], real[], vector)
+real skew_normal_cdf(real, real[], real[], row_vector)
+real skew_normal_cdf(vector, real, real, real)
+real skew_normal_cdf(vector, real, real, vector)
+real skew_normal_cdf(vector, real, real, row_vector)
+real skew_normal_cdf(vector, real, real, real[])
+real skew_normal_cdf(vector, real, vector, real)
+real skew_normal_cdf(vector, real, vector, vector)
+real skew_normal_cdf(vector, real, vector, row_vector)
+real skew_normal_cdf(vector, real, vector, real[])
+real skew_normal_cdf(vector, real, row_vector, real)
+real skew_normal_cdf(vector, real, row_vector, vector)
+real skew_normal_cdf(vector, real, row_vector, row_vector)
+real skew_normal_cdf(vector, real, row_vector, real[])
+real skew_normal_cdf(vector, real, real[], real)
+real skew_normal_cdf(vector, real, real[], vector)
+real skew_normal_cdf(vector, real, real[], row_vector)
+real skew_normal_cdf(vector, real, real[], real[])
+real skew_normal_cdf(vector, vector, real, real)
+real skew_normal_cdf(vector, vector, real, vector)
+real skew_normal_cdf(vector, vector, real, row_vector)
+real skew_normal_cdf(vector, vector, real, real[])
+real skew_normal_cdf(vector, vector, vector, real)
+real skew_normal_cdf(vector, vector, vector, vector)
+real skew_normal_cdf(vector, vector, vector, row_vector)
+real skew_normal_cdf(vector, vector, vector, real[])
+real skew_normal_cdf(vector, vector, row_vector, real)
+real skew_normal_cdf(vector, vector, row_vector, vector)
+real skew_normal_cdf(vector, vector, row_vector, row_vector)
+real skew_normal_cdf(vector, vector, row_vector, real[])
+real skew_normal_cdf(vector, vector, real[], real)
+real skew_normal_cdf(vector, vector, real[], vector)
+real skew_normal_cdf(vector, vector, real[], row_vector)
+real skew_normal_cdf(vector, vector, real[], real[])
+real skew_normal_cdf(vector, row_vector, real, real)
+real skew_normal_cdf(vector, row_vector, real, vector)
+real skew_normal_cdf(vector, row_vector, real, row_vector)
+real skew_normal_cdf(vector, row_vector, real, real[])
+real skew_normal_cdf(vector, row_vector, vector, real)
+real skew_normal_cdf(vector, row_vector, vector, vector)
+real skew_normal_cdf(vector, row_vector, vector, row_vector)
+real skew_normal_cdf(vector, row_vector, vector, real[])
+real skew_normal_cdf(vector, row_vector, row_vector, real)
+real skew_normal_cdf(vector, row_vector, row_vector, vector)
+real skew_normal_cdf(vector, row_vector, row_vector, row_vector)
+real skew_normal_cdf(vector, row_vector, row_vector, real[])
+real skew_normal_cdf(vector, row_vector, real[], real)
+real skew_normal_cdf(vector, row_vector, real[], vector)
+real skew_normal_cdf(vector, row_vector, real[], row_vector)
+real skew_normal_cdf(vector, row_vector, real[], real[])
+real skew_normal_cdf(vector, real[], real, real)
+real skew_normal_cdf(vector, real[], real, vector)
+real skew_normal_cdf(vector, real[], real, row_vector)
+real skew_normal_cdf(vector, real[], real, real[])
+real skew_normal_cdf(vector, real[], vector, real)
+real skew_normal_cdf(vector, real[], vector, vector)
+real skew_normal_cdf(vector, real[], vector, row_vector)
+real skew_normal_cdf(vector, real[], vector, real[])
+real skew_normal_cdf(vector, real[], row_vector, real)
+real skew_normal_cdf(vector, real[], row_vector, vector)
+real skew_normal_cdf(vector, real[], row_vector, row_vector)
+real skew_normal_cdf(vector, real[], row_vector, real[])
+real skew_normal_cdf(vector, real[], real[], real)
+real skew_normal_cdf(vector, real[], real[], vector)
+real skew_normal_cdf(vector, real[], real[], row_vector)
+real skew_normal_cdf(vector, real[], real[], real[])
+real skew_normal_cdf(row_vector, real, real, real)
+real skew_normal_cdf(row_vector, real, real, vector)
+real skew_normal_cdf(row_vector, real, real, row_vector)
+real skew_normal_cdf(row_vector, real, real, real[])
+real skew_normal_cdf(row_vector, real, vector, real)
+real skew_normal_cdf(row_vector, real, vector, vector)
+real skew_normal_cdf(row_vector, real, vector, row_vector)
+real skew_normal_cdf(row_vector, real, vector, real[])
+real skew_normal_cdf(row_vector, real, row_vector, real)
+real skew_normal_cdf(row_vector, real, row_vector, vector)
+real skew_normal_cdf(row_vector, real, row_vector, row_vector)
+real skew_normal_cdf(row_vector, real, row_vector, real[])
+real skew_normal_cdf(row_vector, real, real[], real)
+real skew_normal_cdf(row_vector, real, real[], vector)
+real skew_normal_cdf(row_vector, real, real[], row_vector)
+real skew_normal_cdf(row_vector, real, real[], real[])
+real skew_normal_cdf(row_vector, vector, real, real)
+real skew_normal_cdf(row_vector, vector, real, vector)
+real skew_normal_cdf(row_vector, vector, real, row_vector)
+real skew_normal_cdf(row_vector, vector, real, real[])
+real skew_normal_cdf(row_vector, vector, vector, real)
+real skew_normal_cdf(row_vector, vector, vector, vector)
+real skew_normal_cdf(row_vector, vector, vector, row_vector)
+real skew_normal_cdf(row_vector, vector, vector, real[])
+real skew_normal_cdf(row_vector, vector, row_vector, real)
+real skew_normal_cdf(row_vector, vector, row_vector, vector)
+real skew_normal_cdf(row_vector, vector, row_vector, row_vector)
+real skew_normal_cdf(row_vector, vector, row_vector, real[])
+real skew_normal_cdf(row_vector, vector, real[], real)
+real skew_normal_cdf(row_vector, vector, real[], vector)
+real skew_normal_cdf(row_vector, vector, real[], row_vector)
+real skew_normal_cdf(row_vector, vector, real[], real[])
+real skew_normal_cdf(row_vector, row_vector, real, real)
+real skew_normal_cdf(row_vector, row_vector, real, vector)
+real skew_normal_cdf(row_vector, row_vector, real, row_vector)
+real skew_normal_cdf(row_vector, row_vector, real, real[])
+real skew_normal_cdf(row_vector, row_vector, vector, real)
+real skew_normal_cdf(row_vector, row_vector, vector, vector)
+real skew_normal_cdf(row_vector, row_vector, vector, row_vector)
+real skew_normal_cdf(row_vector, row_vector, vector, real[])
+real skew_normal_cdf(row_vector, row_vector, row_vector, real)
+real skew_normal_cdf(row_vector, row_vector, row_vector, vector)
+real skew_normal_cdf(row_vector, row_vector, row_vector, row_vector)
+real skew_normal_cdf(row_vector, row_vector, row_vector, real[])
+real skew_normal_cdf(row_vector, row_vector, real[], real)
+real skew_normal_cdf(row_vector, row_vector, real[], vector)
+real skew_normal_cdf(row_vector, row_vector, real[], row_vector)
+real skew_normal_cdf(row_vector, row_vector, real[], real[])
+real skew_normal_cdf(row_vector, real[], real, real)
+real skew_normal_cdf(row_vector, real[], real, vector)
+real skew_normal_cdf(row_vector, real[], real, row_vector)
+real skew_normal_cdf(row_vector, real[], real, real[])
+real skew_normal_cdf(row_vector, real[], vector, real)
+real skew_normal_cdf(row_vector, real[], vector, vector)
+real skew_normal_cdf(row_vector, real[], vector, row_vector)
+real skew_normal_cdf(row_vector, real[], vector, real[])
+real skew_normal_cdf(row_vector, real[], row_vector, real)
+real skew_normal_cdf(row_vector, real[], row_vector, vector)
+real skew_normal_cdf(row_vector, real[], row_vector, row_vector)
+real skew_normal_cdf(row_vector, real[], row_vector, real[])
+real skew_normal_cdf(row_vector, real[], real[], real)
+real skew_normal_cdf(row_vector, real[], real[], vector)
+real skew_normal_cdf(row_vector, real[], real[], row_vector)
+real skew_normal_cdf(row_vector, real[], real[], real[])
+real skew_normal_cdf(real[], real, real, vector)
+real skew_normal_cdf(real[], real, real, row_vector)
+real skew_normal_cdf(real[], real, vector, real)
+real skew_normal_cdf(real[], real, vector, vector)
+real skew_normal_cdf(real[], real, vector, row_vector)
+real skew_normal_cdf(real[], real, vector, real[])
+real skew_normal_cdf(real[], real, row_vector, real)
+real skew_normal_cdf(real[], real, row_vector, vector)
+real skew_normal_cdf(real[], real, row_vector, row_vector)
+real skew_normal_cdf(real[], real, row_vector, real[])
+real skew_normal_cdf(real[], real, real[], vector)
+real skew_normal_cdf(real[], real, real[], row_vector)
+real skew_normal_cdf(real[], vector, real, real)
+real skew_normal_cdf(real[], vector, real, vector)
+real skew_normal_cdf(real[], vector, real, row_vector)
+real skew_normal_cdf(real[], vector, real, real[])
+real skew_normal_cdf(real[], vector, vector, real)
+real skew_normal_cdf(real[], vector, vector, vector)
+real skew_normal_cdf(real[], vector, vector, row_vector)
+real skew_normal_cdf(real[], vector, vector, real[])
+real skew_normal_cdf(real[], vector, row_vector, real)
+real skew_normal_cdf(real[], vector, row_vector, vector)
+real skew_normal_cdf(real[], vector, row_vector, row_vector)
+real skew_normal_cdf(real[], vector, row_vector, real[])
+real skew_normal_cdf(real[], vector, real[], real)
+real skew_normal_cdf(real[], vector, real[], vector)
+real skew_normal_cdf(real[], vector, real[], row_vector)
+real skew_normal_cdf(real[], vector, real[], real[])
+real skew_normal_cdf(real[], row_vector, real, real)
+real skew_normal_cdf(real[], row_vector, real, vector)
+real skew_normal_cdf(real[], row_vector, real, row_vector)
+real skew_normal_cdf(real[], row_vector, real, real[])
+real skew_normal_cdf(real[], row_vector, vector, real)
+real skew_normal_cdf(real[], row_vector, vector, vector)
+real skew_normal_cdf(real[], row_vector, vector, row_vector)
+real skew_normal_cdf(real[], row_vector, vector, real[])
+real skew_normal_cdf(real[], row_vector, row_vector, real)
+real skew_normal_cdf(real[], row_vector, row_vector, vector)
+real skew_normal_cdf(real[], row_vector, row_vector, row_vector)
+real skew_normal_cdf(real[], row_vector, row_vector, real[])
+real skew_normal_cdf(real[], row_vector, real[], real)
+real skew_normal_cdf(real[], row_vector, real[], vector)
+real skew_normal_cdf(real[], row_vector, real[], row_vector)
+real skew_normal_cdf(real[], row_vector, real[], real[])
+real skew_normal_cdf(real[], real[], real, vector)
+real skew_normal_cdf(real[], real[], real, row_vector)
+real skew_normal_cdf(real[], real[], vector, real)
+real skew_normal_cdf(real[], real[], vector, vector)
+real skew_normal_cdf(real[], real[], vector, row_vector)
+real skew_normal_cdf(real[], real[], vector, real[])
+real skew_normal_cdf(real[], real[], row_vector, real)
+real skew_normal_cdf(real[], real[], row_vector, vector)
+real skew_normal_cdf(real[], real[], row_vector, row_vector)
+real skew_normal_cdf(real[], real[], row_vector, real[])
+real skew_normal_cdf(real[], real[], real[], vector)
+real skew_normal_cdf(real[], real[], real[], row_vector)
+real skew_normal_cdf_log(real, real, real, vector)
+real skew_normal_cdf_log(real, real, real, row_vector)
+real skew_normal_cdf_log(real, real, vector, real)
+real skew_normal_cdf_log(real, real, vector, vector)
+real skew_normal_cdf_log(real, real, vector, row_vector)
+real skew_normal_cdf_log(real, real, vector, real[])
+real skew_normal_cdf_log(real, real, row_vector, real)
+real skew_normal_cdf_log(real, real, row_vector, vector)
+real skew_normal_cdf_log(real, real, row_vector, row_vector)
+real skew_normal_cdf_log(real, real, row_vector, real[])
+real skew_normal_cdf_log(real, real, real[], vector)
+real skew_normal_cdf_log(real, real, real[], row_vector)
+real skew_normal_cdf_log(real, vector, real, real)
+real skew_normal_cdf_log(real, vector, real, vector)
+real skew_normal_cdf_log(real, vector, real, row_vector)
+real skew_normal_cdf_log(real, vector, real, real[])
+real skew_normal_cdf_log(real, vector, vector, real)
+real skew_normal_cdf_log(real, vector, vector, vector)
+real skew_normal_cdf_log(real, vector, vector, row_vector)
+real skew_normal_cdf_log(real, vector, vector, real[])
+real skew_normal_cdf_log(real, vector, row_vector, real)
+real skew_normal_cdf_log(real, vector, row_vector, vector)
+real skew_normal_cdf_log(real, vector, row_vector, row_vector)
+real skew_normal_cdf_log(real, vector, row_vector, real[])
+real skew_normal_cdf_log(real, vector, real[], real)
+real skew_normal_cdf_log(real, vector, real[], vector)
+real skew_normal_cdf_log(real, vector, real[], row_vector)
+real skew_normal_cdf_log(real, vector, real[], real[])
+real skew_normal_cdf_log(real, row_vector, real, real)
+real skew_normal_cdf_log(real, row_vector, real, vector)
+real skew_normal_cdf_log(real, row_vector, real, row_vector)
+real skew_normal_cdf_log(real, row_vector, real, real[])
+real skew_normal_cdf_log(real, row_vector, vector, real)
+real skew_normal_cdf_log(real, row_vector, vector, vector)
+real skew_normal_cdf_log(real, row_vector, vector, row_vector)
+real skew_normal_cdf_log(real, row_vector, vector, real[])
+real skew_normal_cdf_log(real, row_vector, row_vector, real)
+real skew_normal_cdf_log(real, row_vector, row_vector, vector)
+real skew_normal_cdf_log(real, row_vector, row_vector, row_vector)
+real skew_normal_cdf_log(real, row_vector, row_vector, real[])
+real skew_normal_cdf_log(real, row_vector, real[], real)
+real skew_normal_cdf_log(real, row_vector, real[], vector)
+real skew_normal_cdf_log(real, row_vector, real[], row_vector)
+real skew_normal_cdf_log(real, row_vector, real[], real[])
+real skew_normal_cdf_log(real, real[], real, vector)
+real skew_normal_cdf_log(real, real[], real, row_vector)
+real skew_normal_cdf_log(real, real[], vector, real)
+real skew_normal_cdf_log(real, real[], vector, vector)
+real skew_normal_cdf_log(real, real[], vector, row_vector)
+real skew_normal_cdf_log(real, real[], vector, real[])
+real skew_normal_cdf_log(real, real[], row_vector, real)
+real skew_normal_cdf_log(real, real[], row_vector, vector)
+real skew_normal_cdf_log(real, real[], row_vector, row_vector)
+real skew_normal_cdf_log(real, real[], row_vector, real[])
+real skew_normal_cdf_log(real, real[], real[], vector)
+real skew_normal_cdf_log(real, real[], real[], row_vector)
+real skew_normal_cdf_log(vector, real, real, real)
+real skew_normal_cdf_log(vector, real, real, vector)
+real skew_normal_cdf_log(vector, real, real, row_vector)
+real skew_normal_cdf_log(vector, real, real, real[])
+real skew_normal_cdf_log(vector, real, vector, real)
+real skew_normal_cdf_log(vector, real, vector, vector)
+real skew_normal_cdf_log(vector, real, vector, row_vector)
+real skew_normal_cdf_log(vector, real, vector, real[])
+real skew_normal_cdf_log(vector, real, row_vector, real)
+real skew_normal_cdf_log(vector, real, row_vector, vector)
+real skew_normal_cdf_log(vector, real, row_vector, row_vector)
+real skew_normal_cdf_log(vector, real, row_vector, real[])
+real skew_normal_cdf_log(vector, real, real[], real)
+real skew_normal_cdf_log(vector, real, real[], vector)
+real skew_normal_cdf_log(vector, real, real[], row_vector)
+real skew_normal_cdf_log(vector, real, real[], real[])
+real skew_normal_cdf_log(vector, vector, real, real)
+real skew_normal_cdf_log(vector, vector, real, vector)
+real skew_normal_cdf_log(vector, vector, real, row_vector)
+real skew_normal_cdf_log(vector, vector, real, real[])
+real skew_normal_cdf_log(vector, vector, vector, real)
+real skew_normal_cdf_log(vector, vector, vector, vector)
+real skew_normal_cdf_log(vector, vector, vector, row_vector)
+real skew_normal_cdf_log(vector, vector, vector, real[])
+real skew_normal_cdf_log(vector, vector, row_vector, real)
+real skew_normal_cdf_log(vector, vector, row_vector, vector)
+real skew_normal_cdf_log(vector, vector, row_vector, row_vector)
+real skew_normal_cdf_log(vector, vector, row_vector, real[])
+real skew_normal_cdf_log(vector, vector, real[], real)
+real skew_normal_cdf_log(vector, vector, real[], vector)
+real skew_normal_cdf_log(vector, vector, real[], row_vector)
+real skew_normal_cdf_log(vector, vector, real[], real[])
+real skew_normal_cdf_log(vector, row_vector, real, real)
+real skew_normal_cdf_log(vector, row_vector, real, vector)
+real skew_normal_cdf_log(vector, row_vector, real, row_vector)
+real skew_normal_cdf_log(vector, row_vector, real, real[])
+real skew_normal_cdf_log(vector, row_vector, vector, real)
+real skew_normal_cdf_log(vector, row_vector, vector, vector)
+real skew_normal_cdf_log(vector, row_vector, vector, row_vector)
+real skew_normal_cdf_log(vector, row_vector, vector, real[])
+real skew_normal_cdf_log(vector, row_vector, row_vector, real)
+real skew_normal_cdf_log(vector, row_vector, row_vector, vector)
+real skew_normal_cdf_log(vector, row_vector, row_vector, row_vector)
+real skew_normal_cdf_log(vector, row_vector, row_vector, real[])
+real skew_normal_cdf_log(vector, row_vector, real[], real)
+real skew_normal_cdf_log(vector, row_vector, real[], vector)
+real skew_normal_cdf_log(vector, row_vector, real[], row_vector)
+real skew_normal_cdf_log(vector, row_vector, real[], real[])
+real skew_normal_cdf_log(vector, real[], real, real)
+real skew_normal_cdf_log(vector, real[], real, vector)
+real skew_normal_cdf_log(vector, real[], real, row_vector)
+real skew_normal_cdf_log(vector, real[], real, real[])
+real skew_normal_cdf_log(vector, real[], vector, real)
+real skew_normal_cdf_log(vector, real[], vector, vector)
+real skew_normal_cdf_log(vector, real[], vector, row_vector)
+real skew_normal_cdf_log(vector, real[], vector, real[])
+real skew_normal_cdf_log(vector, real[], row_vector, real)
+real skew_normal_cdf_log(vector, real[], row_vector, vector)
+real skew_normal_cdf_log(vector, real[], row_vector, row_vector)
+real skew_normal_cdf_log(vector, real[], row_vector, real[])
+real skew_normal_cdf_log(vector, real[], real[], real)
+real skew_normal_cdf_log(vector, real[], real[], vector)
+real skew_normal_cdf_log(vector, real[], real[], row_vector)
+real skew_normal_cdf_log(vector, real[], real[], real[])
+real skew_normal_cdf_log(row_vector, real, real, real)
+real skew_normal_cdf_log(row_vector, real, real, vector)
+real skew_normal_cdf_log(row_vector, real, real, row_vector)
+real skew_normal_cdf_log(row_vector, real, real, real[])
+real skew_normal_cdf_log(row_vector, real, vector, real)
+real skew_normal_cdf_log(row_vector, real, vector, vector)
+real skew_normal_cdf_log(row_vector, real, vector, row_vector)
+real skew_normal_cdf_log(row_vector, real, vector, real[])
+real skew_normal_cdf_log(row_vector, real, row_vector, real)
+real skew_normal_cdf_log(row_vector, real, row_vector, vector)
+real skew_normal_cdf_log(row_vector, real, row_vector, row_vector)
+real skew_normal_cdf_log(row_vector, real, row_vector, real[])
+real skew_normal_cdf_log(row_vector, real, real[], real)
+real skew_normal_cdf_log(row_vector, real, real[], vector)
+real skew_normal_cdf_log(row_vector, real, real[], row_vector)
+real skew_normal_cdf_log(row_vector, real, real[], real[])
+real skew_normal_cdf_log(row_vector, vector, real, real)
+real skew_normal_cdf_log(row_vector, vector, real, vector)
+real skew_normal_cdf_log(row_vector, vector, real, row_vector)
+real skew_normal_cdf_log(row_vector, vector, real, real[])
+real skew_normal_cdf_log(row_vector, vector, vector, real)
+real skew_normal_cdf_log(row_vector, vector, vector, vector)
+real skew_normal_cdf_log(row_vector, vector, vector, row_vector)
+real skew_normal_cdf_log(row_vector, vector, vector, real[])
+real skew_normal_cdf_log(row_vector, vector, row_vector, real)
+real skew_normal_cdf_log(row_vector, vector, row_vector, vector)
+real skew_normal_cdf_log(row_vector, vector, row_vector, row_vector)
+real skew_normal_cdf_log(row_vector, vector, row_vector, real[])
+real skew_normal_cdf_log(row_vector, vector, real[], real)
+real skew_normal_cdf_log(row_vector, vector, real[], vector)
+real skew_normal_cdf_log(row_vector, vector, real[], row_vector)
+real skew_normal_cdf_log(row_vector, vector, real[], real[])
+real skew_normal_cdf_log(row_vector, row_vector, real, real)
+real skew_normal_cdf_log(row_vector, row_vector, real, vector)
+real skew_normal_cdf_log(row_vector, row_vector, real, row_vector)
+real skew_normal_cdf_log(row_vector, row_vector, real, real[])
+real skew_normal_cdf_log(row_vector, row_vector, vector, real)
+real skew_normal_cdf_log(row_vector, row_vector, vector, vector)
+real skew_normal_cdf_log(row_vector, row_vector, vector, row_vector)
+real skew_normal_cdf_log(row_vector, row_vector, vector, real[])
+real skew_normal_cdf_log(row_vector, row_vector, row_vector, real)
+real skew_normal_cdf_log(row_vector, row_vector, row_vector, vector)
+real skew_normal_cdf_log(row_vector, row_vector, row_vector, row_vector)
+real skew_normal_cdf_log(row_vector, row_vector, row_vector, real[])
+real skew_normal_cdf_log(row_vector, row_vector, real[], real)
+real skew_normal_cdf_log(row_vector, row_vector, real[], vector)
+real skew_normal_cdf_log(row_vector, row_vector, real[], row_vector)
+real skew_normal_cdf_log(row_vector, row_vector, real[], real[])
+real skew_normal_cdf_log(row_vector, real[], real, real)
+real skew_normal_cdf_log(row_vector, real[], real, vector)
+real skew_normal_cdf_log(row_vector, real[], real, row_vector)
+real skew_normal_cdf_log(row_vector, real[], real, real[])
+real skew_normal_cdf_log(row_vector, real[], vector, real)
+real skew_normal_cdf_log(row_vector, real[], vector, vector)
+real skew_normal_cdf_log(row_vector, real[], vector, row_vector)
+real skew_normal_cdf_log(row_vector, real[], vector, real[])
+real skew_normal_cdf_log(row_vector, real[], row_vector, real)
+real skew_normal_cdf_log(row_vector, real[], row_vector, vector)
+real skew_normal_cdf_log(row_vector, real[], row_vector, row_vector)
+real skew_normal_cdf_log(row_vector, real[], row_vector, real[])
+real skew_normal_cdf_log(row_vector, real[], real[], real)
+real skew_normal_cdf_log(row_vector, real[], real[], vector)
+real skew_normal_cdf_log(row_vector, real[], real[], row_vector)
+real skew_normal_cdf_log(row_vector, real[], real[], real[])
+real skew_normal_cdf_log(real[], real, real, vector)
+real skew_normal_cdf_log(real[], real, real, row_vector)
+real skew_normal_cdf_log(real[], real, vector, real)
+real skew_normal_cdf_log(real[], real, vector, vector)
+real skew_normal_cdf_log(real[], real, vector, row_vector)
+real skew_normal_cdf_log(real[], real, vector, real[])
+real skew_normal_cdf_log(real[], real, row_vector, real)
+real skew_normal_cdf_log(real[], real, row_vector, vector)
+real skew_normal_cdf_log(real[], real, row_vector, row_vector)
+real skew_normal_cdf_log(real[], real, row_vector, real[])
+real skew_normal_cdf_log(real[], real, real[], vector)
+real skew_normal_cdf_log(real[], real, real[], row_vector)
+real skew_normal_cdf_log(real[], vector, real, real)
+real skew_normal_cdf_log(real[], vector, real, vector)
+real skew_normal_cdf_log(real[], vector, real, row_vector)
+real skew_normal_cdf_log(real[], vector, real, real[])
+real skew_normal_cdf_log(real[], vector, vector, real)
+real skew_normal_cdf_log(real[], vector, vector, vector)
+real skew_normal_cdf_log(real[], vector, vector, row_vector)
+real skew_normal_cdf_log(real[], vector, vector, real[])
+real skew_normal_cdf_log(real[], vector, row_vector, real)
+real skew_normal_cdf_log(real[], vector, row_vector, vector)
+real skew_normal_cdf_log(real[], vector, row_vector, row_vector)
+real skew_normal_cdf_log(real[], vector, row_vector, real[])
+real skew_normal_cdf_log(real[], vector, real[], real)
+real skew_normal_cdf_log(real[], vector, real[], vector)
+real skew_normal_cdf_log(real[], vector, real[], row_vector)
+real skew_normal_cdf_log(real[], vector, real[], real[])
+real skew_normal_cdf_log(real[], row_vector, real, real)
+real skew_normal_cdf_log(real[], row_vector, real, vector)
+real skew_normal_cdf_log(real[], row_vector, real, row_vector)
+real skew_normal_cdf_log(real[], row_vector, real, real[])
+real skew_normal_cdf_log(real[], row_vector, vector, real)
+real skew_normal_cdf_log(real[], row_vector, vector, vector)
+real skew_normal_cdf_log(real[], row_vector, vector, row_vector)
+real skew_normal_cdf_log(real[], row_vector, vector, real[])
+real skew_normal_cdf_log(real[], row_vector, row_vector, real)
+real skew_normal_cdf_log(real[], row_vector, row_vector, vector)
+real skew_normal_cdf_log(real[], row_vector, row_vector, row_vector)
+real skew_normal_cdf_log(real[], row_vector, row_vector, real[])
+real skew_normal_cdf_log(real[], row_vector, real[], real)
+real skew_normal_cdf_log(real[], row_vector, real[], vector)
+real skew_normal_cdf_log(real[], row_vector, real[], row_vector)
+real skew_normal_cdf_log(real[], row_vector, real[], real[])
+real skew_normal_cdf_log(real[], real[], real, vector)
+real skew_normal_cdf_log(real[], real[], real, row_vector)
+real skew_normal_cdf_log(real[], real[], vector, real)
+real skew_normal_cdf_log(real[], real[], vector, vector)
+real skew_normal_cdf_log(real[], real[], vector, row_vector)
+real skew_normal_cdf_log(real[], real[], vector, real[])
+real skew_normal_cdf_log(real[], real[], row_vector, real)
+real skew_normal_cdf_log(real[], real[], row_vector, vector)
+real skew_normal_cdf_log(real[], real[], row_vector, row_vector)
+real skew_normal_cdf_log(real[], real[], row_vector, real[])
+real skew_normal_cdf_log(real[], real[], real[], vector)
+real skew_normal_cdf_log(real[], real[], real[], row_vector)
+real skew_normal_lccdf(real, real, real, vector)
+real skew_normal_lccdf(real, real, real, row_vector)
+real skew_normal_lccdf(real, real, vector, real)
+real skew_normal_lccdf(real, real, vector, vector)
+real skew_normal_lccdf(real, real, vector, row_vector)
+real skew_normal_lccdf(real, real, vector, real[])
+real skew_normal_lccdf(real, real, row_vector, real)
+real skew_normal_lccdf(real, real, row_vector, vector)
+real skew_normal_lccdf(real, real, row_vector, row_vector)
+real skew_normal_lccdf(real, real, row_vector, real[])
+real skew_normal_lccdf(real, real, real[], vector)
+real skew_normal_lccdf(real, real, real[], row_vector)
+real skew_normal_lccdf(real, vector, real, real)
+real skew_normal_lccdf(real, vector, real, vector)
+real skew_normal_lccdf(real, vector, real, row_vector)
+real skew_normal_lccdf(real, vector, real, real[])
+real skew_normal_lccdf(real, vector, vector, real)
+real skew_normal_lccdf(real, vector, vector, vector)
+real skew_normal_lccdf(real, vector, vector, row_vector)
+real skew_normal_lccdf(real, vector, vector, real[])
+real skew_normal_lccdf(real, vector, row_vector, real)
+real skew_normal_lccdf(real, vector, row_vector, vector)
+real skew_normal_lccdf(real, vector, row_vector, row_vector)
+real skew_normal_lccdf(real, vector, row_vector, real[])
+real skew_normal_lccdf(real, vector, real[], real)
+real skew_normal_lccdf(real, vector, real[], vector)
+real skew_normal_lccdf(real, vector, real[], row_vector)
+real skew_normal_lccdf(real, vector, real[], real[])
+real skew_normal_lccdf(real, row_vector, real, real)
+real skew_normal_lccdf(real, row_vector, real, vector)
+real skew_normal_lccdf(real, row_vector, real, row_vector)
+real skew_normal_lccdf(real, row_vector, real, real[])
+real skew_normal_lccdf(real, row_vector, vector, real)
+real skew_normal_lccdf(real, row_vector, vector, vector)
+real skew_normal_lccdf(real, row_vector, vector, row_vector)
+real skew_normal_lccdf(real, row_vector, vector, real[])
+real skew_normal_lccdf(real, row_vector, row_vector, real)
+real skew_normal_lccdf(real, row_vector, row_vector, vector)
+real skew_normal_lccdf(real, row_vector, row_vector, row_vector)
+real skew_normal_lccdf(real, row_vector, row_vector, real[])
+real skew_normal_lccdf(real, row_vector, real[], real)
+real skew_normal_lccdf(real, row_vector, real[], vector)
+real skew_normal_lccdf(real, row_vector, real[], row_vector)
+real skew_normal_lccdf(real, row_vector, real[], real[])
+real skew_normal_lccdf(real, real[], real, vector)
+real skew_normal_lccdf(real, real[], real, row_vector)
+real skew_normal_lccdf(real, real[], vector, real)
+real skew_normal_lccdf(real, real[], vector, vector)
+real skew_normal_lccdf(real, real[], vector, row_vector)
+real skew_normal_lccdf(real, real[], vector, real[])
+real skew_normal_lccdf(real, real[], row_vector, real)
+real skew_normal_lccdf(real, real[], row_vector, vector)
+real skew_normal_lccdf(real, real[], row_vector, row_vector)
+real skew_normal_lccdf(real, real[], row_vector, real[])
+real skew_normal_lccdf(real, real[], real[], vector)
+real skew_normal_lccdf(real, real[], real[], row_vector)
+real skew_normal_lccdf(vector, real, real, real)
+real skew_normal_lccdf(vector, real, real, vector)
+real skew_normal_lccdf(vector, real, real, row_vector)
+real skew_normal_lccdf(vector, real, real, real[])
+real skew_normal_lccdf(vector, real, vector, real)
+real skew_normal_lccdf(vector, real, vector, vector)
+real skew_normal_lccdf(vector, real, vector, row_vector)
+real skew_normal_lccdf(vector, real, vector, real[])
+real skew_normal_lccdf(vector, real, row_vector, real)
+real skew_normal_lccdf(vector, real, row_vector, vector)
+real skew_normal_lccdf(vector, real, row_vector, row_vector)
+real skew_normal_lccdf(vector, real, row_vector, real[])
+real skew_normal_lccdf(vector, real, real[], real)
+real skew_normal_lccdf(vector, real, real[], vector)
+real skew_normal_lccdf(vector, real, real[], row_vector)
+real skew_normal_lccdf(vector, real, real[], real[])
+real skew_normal_lccdf(vector, vector, real, real)
+real skew_normal_lccdf(vector, vector, real, vector)
+real skew_normal_lccdf(vector, vector, real, row_vector)
+real skew_normal_lccdf(vector, vector, real, real[])
+real skew_normal_lccdf(vector, vector, vector, real)
+real skew_normal_lccdf(vector, vector, vector, vector)
+real skew_normal_lccdf(vector, vector, vector, row_vector)
+real skew_normal_lccdf(vector, vector, vector, real[])
+real skew_normal_lccdf(vector, vector, row_vector, real)
+real skew_normal_lccdf(vector, vector, row_vector, vector)
+real skew_normal_lccdf(vector, vector, row_vector, row_vector)
+real skew_normal_lccdf(vector, vector, row_vector, real[])
+real skew_normal_lccdf(vector, vector, real[], real)
+real skew_normal_lccdf(vector, vector, real[], vector)
+real skew_normal_lccdf(vector, vector, real[], row_vector)
+real skew_normal_lccdf(vector, vector, real[], real[])
+real skew_normal_lccdf(vector, row_vector, real, real)
+real skew_normal_lccdf(vector, row_vector, real, vector)
+real skew_normal_lccdf(vector, row_vector, real, row_vector)
+real skew_normal_lccdf(vector, row_vector, real, real[])
+real skew_normal_lccdf(vector, row_vector, vector, real)
+real skew_normal_lccdf(vector, row_vector, vector, vector)
+real skew_normal_lccdf(vector, row_vector, vector, row_vector)
+real skew_normal_lccdf(vector, row_vector, vector, real[])
+real skew_normal_lccdf(vector, row_vector, row_vector, real)
+real skew_normal_lccdf(vector, row_vector, row_vector, vector)
+real skew_normal_lccdf(vector, row_vector, row_vector, row_vector)
+real skew_normal_lccdf(vector, row_vector, row_vector, real[])
+real skew_normal_lccdf(vector, row_vector, real[], real)
+real skew_normal_lccdf(vector, row_vector, real[], vector)
+real skew_normal_lccdf(vector, row_vector, real[], row_vector)
+real skew_normal_lccdf(vector, row_vector, real[], real[])
+real skew_normal_lccdf(vector, real[], real, real)
+real skew_normal_lccdf(vector, real[], real, vector)
+real skew_normal_lccdf(vector, real[], real, row_vector)
+real skew_normal_lccdf(vector, real[], real, real[])
+real skew_normal_lccdf(vector, real[], vector, real)
+real skew_normal_lccdf(vector, real[], vector, vector)
+real skew_normal_lccdf(vector, real[], vector, row_vector)
+real skew_normal_lccdf(vector, real[], vector, real[])
+real skew_normal_lccdf(vector, real[], row_vector, real)
+real skew_normal_lccdf(vector, real[], row_vector, vector)
+real skew_normal_lccdf(vector, real[], row_vector, row_vector)
+real skew_normal_lccdf(vector, real[], row_vector, real[])
+real skew_normal_lccdf(vector, real[], real[], real)
+real skew_normal_lccdf(vector, real[], real[], vector)
+real skew_normal_lccdf(vector, real[], real[], row_vector)
+real skew_normal_lccdf(vector, real[], real[], real[])
+real skew_normal_lccdf(row_vector, real, real, real)
+real skew_normal_lccdf(row_vector, real, real, vector)
+real skew_normal_lccdf(row_vector, real, real, row_vector)
+real skew_normal_lccdf(row_vector, real, real, real[])
+real skew_normal_lccdf(row_vector, real, vector, real)
+real skew_normal_lccdf(row_vector, real, vector, vector)
+real skew_normal_lccdf(row_vector, real, vector, row_vector)
+real skew_normal_lccdf(row_vector, real, vector, real[])
+real skew_normal_lccdf(row_vector, real, row_vector, real)
+real skew_normal_lccdf(row_vector, real, row_vector, vector)
+real skew_normal_lccdf(row_vector, real, row_vector, row_vector)
+real skew_normal_lccdf(row_vector, real, row_vector, real[])
+real skew_normal_lccdf(row_vector, real, real[], real)
+real skew_normal_lccdf(row_vector, real, real[], vector)
+real skew_normal_lccdf(row_vector, real, real[], row_vector)
+real skew_normal_lccdf(row_vector, real, real[], real[])
+real skew_normal_lccdf(row_vector, vector, real, real)
+real skew_normal_lccdf(row_vector, vector, real, vector)
+real skew_normal_lccdf(row_vector, vector, real, row_vector)
+real skew_normal_lccdf(row_vector, vector, real, real[])
+real skew_normal_lccdf(row_vector, vector, vector, real)
+real skew_normal_lccdf(row_vector, vector, vector, vector)
+real skew_normal_lccdf(row_vector, vector, vector, row_vector)
+real skew_normal_lccdf(row_vector, vector, vector, real[])
+real skew_normal_lccdf(row_vector, vector, row_vector, real)
+real skew_normal_lccdf(row_vector, vector, row_vector, vector)
+real skew_normal_lccdf(row_vector, vector, row_vector, row_vector)
+real skew_normal_lccdf(row_vector, vector, row_vector, real[])
+real skew_normal_lccdf(row_vector, vector, real[], real)
+real skew_normal_lccdf(row_vector, vector, real[], vector)
+real skew_normal_lccdf(row_vector, vector, real[], row_vector)
+real skew_normal_lccdf(row_vector, vector, real[], real[])
+real skew_normal_lccdf(row_vector, row_vector, real, real)
+real skew_normal_lccdf(row_vector, row_vector, real, vector)
+real skew_normal_lccdf(row_vector, row_vector, real, row_vector)
+real skew_normal_lccdf(row_vector, row_vector, real, real[])
+real skew_normal_lccdf(row_vector, row_vector, vector, real)
+real skew_normal_lccdf(row_vector, row_vector, vector, vector)
+real skew_normal_lccdf(row_vector, row_vector, vector, row_vector)
+real skew_normal_lccdf(row_vector, row_vector, vector, real[])
+real skew_normal_lccdf(row_vector, row_vector, row_vector, real)
+real skew_normal_lccdf(row_vector, row_vector, row_vector, vector)
+real skew_normal_lccdf(row_vector, row_vector, row_vector, row_vector)
+real skew_normal_lccdf(row_vector, row_vector, row_vector, real[])
+real skew_normal_lccdf(row_vector, row_vector, real[], real)
+real skew_normal_lccdf(row_vector, row_vector, real[], vector)
+real skew_normal_lccdf(row_vector, row_vector, real[], row_vector)
+real skew_normal_lccdf(row_vector, row_vector, real[], real[])
+real skew_normal_lccdf(row_vector, real[], real, real)
+real skew_normal_lccdf(row_vector, real[], real, vector)
+real skew_normal_lccdf(row_vector, real[], real, row_vector)
+real skew_normal_lccdf(row_vector, real[], real, real[])
+real skew_normal_lccdf(row_vector, real[], vector, real)
+real skew_normal_lccdf(row_vector, real[], vector, vector)
+real skew_normal_lccdf(row_vector, real[], vector, row_vector)
+real skew_normal_lccdf(row_vector, real[], vector, real[])
+real skew_normal_lccdf(row_vector, real[], row_vector, real)
+real skew_normal_lccdf(row_vector, real[], row_vector, vector)
+real skew_normal_lccdf(row_vector, real[], row_vector, row_vector)
+real skew_normal_lccdf(row_vector, real[], row_vector, real[])
+real skew_normal_lccdf(row_vector, real[], real[], real)
+real skew_normal_lccdf(row_vector, real[], real[], vector)
+real skew_normal_lccdf(row_vector, real[], real[], row_vector)
+real skew_normal_lccdf(row_vector, real[], real[], real[])
+real skew_normal_lccdf(real[], real, real, vector)
+real skew_normal_lccdf(real[], real, real, row_vector)
+real skew_normal_lccdf(real[], real, vector, real)
+real skew_normal_lccdf(real[], real, vector, vector)
+real skew_normal_lccdf(real[], real, vector, row_vector)
+real skew_normal_lccdf(real[], real, vector, real[])
+real skew_normal_lccdf(real[], real, row_vector, real)
+real skew_normal_lccdf(real[], real, row_vector, vector)
+real skew_normal_lccdf(real[], real, row_vector, row_vector)
+real skew_normal_lccdf(real[], real, row_vector, real[])
+real skew_normal_lccdf(real[], real, real[], vector)
+real skew_normal_lccdf(real[], real, real[], row_vector)
+real skew_normal_lccdf(real[], vector, real, real)
+real skew_normal_lccdf(real[], vector, real, vector)
+real skew_normal_lccdf(real[], vector, real, row_vector)
+real skew_normal_lccdf(real[], vector, real, real[])
+real skew_normal_lccdf(real[], vector, vector, real)
+real skew_normal_lccdf(real[], vector, vector, vector)
+real skew_normal_lccdf(real[], vector, vector, row_vector)
+real skew_normal_lccdf(real[], vector, vector, real[])
+real skew_normal_lccdf(real[], vector, row_vector, real)
+real skew_normal_lccdf(real[], vector, row_vector, vector)
+real skew_normal_lccdf(real[], vector, row_vector, row_vector)
+real skew_normal_lccdf(real[], vector, row_vector, real[])
+real skew_normal_lccdf(real[], vector, real[], real)
+real skew_normal_lccdf(real[], vector, real[], vector)
+real skew_normal_lccdf(real[], vector, real[], row_vector)
+real skew_normal_lccdf(real[], vector, real[], real[])
+real skew_normal_lccdf(real[], row_vector, real, real)
+real skew_normal_lccdf(real[], row_vector, real, vector)
+real skew_normal_lccdf(real[], row_vector, real, row_vector)
+real skew_normal_lccdf(real[], row_vector, real, real[])
+real skew_normal_lccdf(real[], row_vector, vector, real)
+real skew_normal_lccdf(real[], row_vector, vector, vector)
+real skew_normal_lccdf(real[], row_vector, vector, row_vector)
+real skew_normal_lccdf(real[], row_vector, vector, real[])
+real skew_normal_lccdf(real[], row_vector, row_vector, real)
+real skew_normal_lccdf(real[], row_vector, row_vector, vector)
+real skew_normal_lccdf(real[], row_vector, row_vector, row_vector)
+real skew_normal_lccdf(real[], row_vector, row_vector, real[])
+real skew_normal_lccdf(real[], row_vector, real[], real)
+real skew_normal_lccdf(real[], row_vector, real[], vector)
+real skew_normal_lccdf(real[], row_vector, real[], row_vector)
+real skew_normal_lccdf(real[], row_vector, real[], real[])
+real skew_normal_lccdf(real[], real[], real, vector)
+real skew_normal_lccdf(real[], real[], real, row_vector)
+real skew_normal_lccdf(real[], real[], vector, real)
+real skew_normal_lccdf(real[], real[], vector, vector)
+real skew_normal_lccdf(real[], real[], vector, row_vector)
+real skew_normal_lccdf(real[], real[], vector, real[])
+real skew_normal_lccdf(real[], real[], row_vector, real)
+real skew_normal_lccdf(real[], real[], row_vector, vector)
+real skew_normal_lccdf(real[], real[], row_vector, row_vector)
+real skew_normal_lccdf(real[], real[], row_vector, real[])
+real skew_normal_lccdf(real[], real[], real[], vector)
+real skew_normal_lccdf(real[], real[], real[], row_vector)
+real skew_normal_lcdf(real, real, real, vector)
+real skew_normal_lcdf(real, real, real, row_vector)
+real skew_normal_lcdf(real, real, vector, real)
+real skew_normal_lcdf(real, real, vector, vector)
+real skew_normal_lcdf(real, real, vector, row_vector)
+real skew_normal_lcdf(real, real, vector, real[])
+real skew_normal_lcdf(real, real, row_vector, real)
+real skew_normal_lcdf(real, real, row_vector, vector)
+real skew_normal_lcdf(real, real, row_vector, row_vector)
+real skew_normal_lcdf(real, real, row_vector, real[])
+real skew_normal_lcdf(real, real, real[], vector)
+real skew_normal_lcdf(real, real, real[], row_vector)
+real skew_normal_lcdf(real, vector, real, real)
+real skew_normal_lcdf(real, vector, real, vector)
+real skew_normal_lcdf(real, vector, real, row_vector)
+real skew_normal_lcdf(real, vector, real, real[])
+real skew_normal_lcdf(real, vector, vector, real)
+real skew_normal_lcdf(real, vector, vector, vector)
+real skew_normal_lcdf(real, vector, vector, row_vector)
+real skew_normal_lcdf(real, vector, vector, real[])
+real skew_normal_lcdf(real, vector, row_vector, real)
+real skew_normal_lcdf(real, vector, row_vector, vector)
+real skew_normal_lcdf(real, vector, row_vector, row_vector)
+real skew_normal_lcdf(real, vector, row_vector, real[])
+real skew_normal_lcdf(real, vector, real[], real)
+real skew_normal_lcdf(real, vector, real[], vector)
+real skew_normal_lcdf(real, vector, real[], row_vector)
+real skew_normal_lcdf(real, vector, real[], real[])
+real skew_normal_lcdf(real, row_vector, real, real)
+real skew_normal_lcdf(real, row_vector, real, vector)
+real skew_normal_lcdf(real, row_vector, real, row_vector)
+real skew_normal_lcdf(real, row_vector, real, real[])
+real skew_normal_lcdf(real, row_vector, vector, real)
+real skew_normal_lcdf(real, row_vector, vector, vector)
+real skew_normal_lcdf(real, row_vector, vector, row_vector)
+real skew_normal_lcdf(real, row_vector, vector, real[])
+real skew_normal_lcdf(real, row_vector, row_vector, real)
+real skew_normal_lcdf(real, row_vector, row_vector, vector)
+real skew_normal_lcdf(real, row_vector, row_vector, row_vector)
+real skew_normal_lcdf(real, row_vector, row_vector, real[])
+real skew_normal_lcdf(real, row_vector, real[], real)
+real skew_normal_lcdf(real, row_vector, real[], vector)
+real skew_normal_lcdf(real, row_vector, real[], row_vector)
+real skew_normal_lcdf(real, row_vector, real[], real[])
+real skew_normal_lcdf(real, real[], real, vector)
+real skew_normal_lcdf(real, real[], real, row_vector)
+real skew_normal_lcdf(real, real[], vector, real)
+real skew_normal_lcdf(real, real[], vector, vector)
+real skew_normal_lcdf(real, real[], vector, row_vector)
+real skew_normal_lcdf(real, real[], vector, real[])
+real skew_normal_lcdf(real, real[], row_vector, real)
+real skew_normal_lcdf(real, real[], row_vector, vector)
+real skew_normal_lcdf(real, real[], row_vector, row_vector)
+real skew_normal_lcdf(real, real[], row_vector, real[])
+real skew_normal_lcdf(real, real[], real[], vector)
+real skew_normal_lcdf(real, real[], real[], row_vector)
+real skew_normal_lcdf(vector, real, real, real)
+real skew_normal_lcdf(vector, real, real, vector)
+real skew_normal_lcdf(vector, real, real, row_vector)
+real skew_normal_lcdf(vector, real, real, real[])
+real skew_normal_lcdf(vector, real, vector, real)
+real skew_normal_lcdf(vector, real, vector, vector)
+real skew_normal_lcdf(vector, real, vector, row_vector)
+real skew_normal_lcdf(vector, real, vector, real[])
+real skew_normal_lcdf(vector, real, row_vector, real)
+real skew_normal_lcdf(vector, real, row_vector, vector)
+real skew_normal_lcdf(vector, real, row_vector, row_vector)
+real skew_normal_lcdf(vector, real, row_vector, real[])
+real skew_normal_lcdf(vector, real, real[], real)
+real skew_normal_lcdf(vector, real, real[], vector)
+real skew_normal_lcdf(vector, real, real[], row_vector)
+real skew_normal_lcdf(vector, real, real[], real[])
+real skew_normal_lcdf(vector, vector, real, real)
+real skew_normal_lcdf(vector, vector, real, vector)
+real skew_normal_lcdf(vector, vector, real, row_vector)
+real skew_normal_lcdf(vector, vector, real, real[])
+real skew_normal_lcdf(vector, vector, vector, real)
+real skew_normal_lcdf(vector, vector, vector, vector)
+real skew_normal_lcdf(vector, vector, vector, row_vector)
+real skew_normal_lcdf(vector, vector, vector, real[])
+real skew_normal_lcdf(vector, vector, row_vector, real)
+real skew_normal_lcdf(vector, vector, row_vector, vector)
+real skew_normal_lcdf(vector, vector, row_vector, row_vector)
+real skew_normal_lcdf(vector, vector, row_vector, real[])
+real skew_normal_lcdf(vector, vector, real[], real)
+real skew_normal_lcdf(vector, vector, real[], vector)
+real skew_normal_lcdf(vector, vector, real[], row_vector)
+real skew_normal_lcdf(vector, vector, real[], real[])
+real skew_normal_lcdf(vector, row_vector, real, real)
+real skew_normal_lcdf(vector, row_vector, real, vector)
+real skew_normal_lcdf(vector, row_vector, real, row_vector)
+real skew_normal_lcdf(vector, row_vector, real, real[])
+real skew_normal_lcdf(vector, row_vector, vector, real)
+real skew_normal_lcdf(vector, row_vector, vector, vector)
+real skew_normal_lcdf(vector, row_vector, vector, row_vector)
+real skew_normal_lcdf(vector, row_vector, vector, real[])
+real skew_normal_lcdf(vector, row_vector, row_vector, real)
+real skew_normal_lcdf(vector, row_vector, row_vector, vector)
+real skew_normal_lcdf(vector, row_vector, row_vector, row_vector)
+real skew_normal_lcdf(vector, row_vector, row_vector, real[])
+real skew_normal_lcdf(vector, row_vector, real[], real)
+real skew_normal_lcdf(vector, row_vector, real[], vector)
+real skew_normal_lcdf(vector, row_vector, real[], row_vector)
+real skew_normal_lcdf(vector, row_vector, real[], real[])
+real skew_normal_lcdf(vector, real[], real, real)
+real skew_normal_lcdf(vector, real[], real, vector)
+real skew_normal_lcdf(vector, real[], real, row_vector)
+real skew_normal_lcdf(vector, real[], real, real[])
+real skew_normal_lcdf(vector, real[], vector, real)
+real skew_normal_lcdf(vector, real[], vector, vector)
+real skew_normal_lcdf(vector, real[], vector, row_vector)
+real skew_normal_lcdf(vector, real[], vector, real[])
+real skew_normal_lcdf(vector, real[], row_vector, real)
+real skew_normal_lcdf(vector, real[], row_vector, vector)
+real skew_normal_lcdf(vector, real[], row_vector, row_vector)
+real skew_normal_lcdf(vector, real[], row_vector, real[])
+real skew_normal_lcdf(vector, real[], real[], real)
+real skew_normal_lcdf(vector, real[], real[], vector)
+real skew_normal_lcdf(vector, real[], real[], row_vector)
+real skew_normal_lcdf(vector, real[], real[], real[])
+real skew_normal_lcdf(row_vector, real, real, real)
+real skew_normal_lcdf(row_vector, real, real, vector)
+real skew_normal_lcdf(row_vector, real, real, row_vector)
+real skew_normal_lcdf(row_vector, real, real, real[])
+real skew_normal_lcdf(row_vector, real, vector, real)
+real skew_normal_lcdf(row_vector, real, vector, vector)
+real skew_normal_lcdf(row_vector, real, vector, row_vector)
+real skew_normal_lcdf(row_vector, real, vector, real[])
+real skew_normal_lcdf(row_vector, real, row_vector, real)
+real skew_normal_lcdf(row_vector, real, row_vector, vector)
+real skew_normal_lcdf(row_vector, real, row_vector, row_vector)
+real skew_normal_lcdf(row_vector, real, row_vector, real[])
+real skew_normal_lcdf(row_vector, real, real[], real)
+real skew_normal_lcdf(row_vector, real, real[], vector)
+real skew_normal_lcdf(row_vector, real, real[], row_vector)
+real skew_normal_lcdf(row_vector, real, real[], real[])
+real skew_normal_lcdf(row_vector, vector, real, real)
+real skew_normal_lcdf(row_vector, vector, real, vector)
+real skew_normal_lcdf(row_vector, vector, real, row_vector)
+real skew_normal_lcdf(row_vector, vector, real, real[])
+real skew_normal_lcdf(row_vector, vector, vector, real)
+real skew_normal_lcdf(row_vector, vector, vector, vector)
+real skew_normal_lcdf(row_vector, vector, vector, row_vector)
+real skew_normal_lcdf(row_vector, vector, vector, real[])
+real skew_normal_lcdf(row_vector, vector, row_vector, real)
+real skew_normal_lcdf(row_vector, vector, row_vector, vector)
+real skew_normal_lcdf(row_vector, vector, row_vector, row_vector)
+real skew_normal_lcdf(row_vector, vector, row_vector, real[])
+real skew_normal_lcdf(row_vector, vector, real[], real)
+real skew_normal_lcdf(row_vector, vector, real[], vector)
+real skew_normal_lcdf(row_vector, vector, real[], row_vector)
+real skew_normal_lcdf(row_vector, vector, real[], real[])
+real skew_normal_lcdf(row_vector, row_vector, real, real)
+real skew_normal_lcdf(row_vector, row_vector, real, vector)
+real skew_normal_lcdf(row_vector, row_vector, real, row_vector)
+real skew_normal_lcdf(row_vector, row_vector, real, real[])
+real skew_normal_lcdf(row_vector, row_vector, vector, real)
+real skew_normal_lcdf(row_vector, row_vector, vector, vector)
+real skew_normal_lcdf(row_vector, row_vector, vector, row_vector)
+real skew_normal_lcdf(row_vector, row_vector, vector, real[])
+real skew_normal_lcdf(row_vector, row_vector, row_vector, real)
+real skew_normal_lcdf(row_vector, row_vector, row_vector, vector)
+real skew_normal_lcdf(row_vector, row_vector, row_vector, row_vector)
+real skew_normal_lcdf(row_vector, row_vector, row_vector, real[])
+real skew_normal_lcdf(row_vector, row_vector, real[], real)
+real skew_normal_lcdf(row_vector, row_vector, real[], vector)
+real skew_normal_lcdf(row_vector, row_vector, real[], row_vector)
+real skew_normal_lcdf(row_vector, row_vector, real[], real[])
+real skew_normal_lcdf(row_vector, real[], real, real)
+real skew_normal_lcdf(row_vector, real[], real, vector)
+real skew_normal_lcdf(row_vector, real[], real, row_vector)
+real skew_normal_lcdf(row_vector, real[], real, real[])
+real skew_normal_lcdf(row_vector, real[], vector, real)
+real skew_normal_lcdf(row_vector, real[], vector, vector)
+real skew_normal_lcdf(row_vector, real[], vector, row_vector)
+real skew_normal_lcdf(row_vector, real[], vector, real[])
+real skew_normal_lcdf(row_vector, real[], row_vector, real)
+real skew_normal_lcdf(row_vector, real[], row_vector, vector)
+real skew_normal_lcdf(row_vector, real[], row_vector, row_vector)
+real skew_normal_lcdf(row_vector, real[], row_vector, real[])
+real skew_normal_lcdf(row_vector, real[], real[], real)
+real skew_normal_lcdf(row_vector, real[], real[], vector)
+real skew_normal_lcdf(row_vector, real[], real[], row_vector)
+real skew_normal_lcdf(row_vector, real[], real[], real[])
+real skew_normal_lcdf(real[], real, real, vector)
+real skew_normal_lcdf(real[], real, real, row_vector)
+real skew_normal_lcdf(real[], real, vector, real)
+real skew_normal_lcdf(real[], real, vector, vector)
+real skew_normal_lcdf(real[], real, vector, row_vector)
+real skew_normal_lcdf(real[], real, vector, real[])
+real skew_normal_lcdf(real[], real, row_vector, real)
+real skew_normal_lcdf(real[], real, row_vector, vector)
+real skew_normal_lcdf(real[], real, row_vector, row_vector)
+real skew_normal_lcdf(real[], real, row_vector, real[])
+real skew_normal_lcdf(real[], real, real[], vector)
+real skew_normal_lcdf(real[], real, real[], row_vector)
+real skew_normal_lcdf(real[], vector, real, real)
+real skew_normal_lcdf(real[], vector, real, vector)
+real skew_normal_lcdf(real[], vector, real, row_vector)
+real skew_normal_lcdf(real[], vector, real, real[])
+real skew_normal_lcdf(real[], vector, vector, real)
+real skew_normal_lcdf(real[], vector, vector, vector)
+real skew_normal_lcdf(real[], vector, vector, row_vector)
+real skew_normal_lcdf(real[], vector, vector, real[])
+real skew_normal_lcdf(real[], vector, row_vector, real)
+real skew_normal_lcdf(real[], vector, row_vector, vector)
+real skew_normal_lcdf(real[], vector, row_vector, row_vector)
+real skew_normal_lcdf(real[], vector, row_vector, real[])
+real skew_normal_lcdf(real[], vector, real[], real)
+real skew_normal_lcdf(real[], vector, real[], vector)
+real skew_normal_lcdf(real[], vector, real[], row_vector)
+real skew_normal_lcdf(real[], vector, real[], real[])
+real skew_normal_lcdf(real[], row_vector, real, real)
+real skew_normal_lcdf(real[], row_vector, real, vector)
+real skew_normal_lcdf(real[], row_vector, real, row_vector)
+real skew_normal_lcdf(real[], row_vector, real, real[])
+real skew_normal_lcdf(real[], row_vector, vector, real)
+real skew_normal_lcdf(real[], row_vector, vector, vector)
+real skew_normal_lcdf(real[], row_vector, vector, row_vector)
+real skew_normal_lcdf(real[], row_vector, vector, real[])
+real skew_normal_lcdf(real[], row_vector, row_vector, real)
+real skew_normal_lcdf(real[], row_vector, row_vector, vector)
+real skew_normal_lcdf(real[], row_vector, row_vector, row_vector)
+real skew_normal_lcdf(real[], row_vector, row_vector, real[])
+real skew_normal_lcdf(real[], row_vector, real[], real)
+real skew_normal_lcdf(real[], row_vector, real[], vector)
+real skew_normal_lcdf(real[], row_vector, real[], row_vector)
+real skew_normal_lcdf(real[], row_vector, real[], real[])
+real skew_normal_lcdf(real[], real[], real, vector)
+real skew_normal_lcdf(real[], real[], real, row_vector)
+real skew_normal_lcdf(real[], real[], vector, real)
+real skew_normal_lcdf(real[], real[], vector, vector)
+real skew_normal_lcdf(real[], real[], vector, row_vector)
+real skew_normal_lcdf(real[], real[], vector, real[])
+real skew_normal_lcdf(real[], real[], row_vector, real)
+real skew_normal_lcdf(real[], real[], row_vector, vector)
+real skew_normal_lcdf(real[], real[], row_vector, row_vector)
+real skew_normal_lcdf(real[], real[], row_vector, real[])
+real skew_normal_lcdf(real[], real[], real[], vector)
+real skew_normal_lcdf(real[], real[], real[], row_vector)
+real skew_normal_log(real, real, real, vector)
+real skew_normal_log(real, real, real, row_vector)
+real skew_normal_log(real, real, vector, real)
+real skew_normal_log(real, real, vector, vector)
+real skew_normal_log(real, real, vector, row_vector)
+real skew_normal_log(real, real, vector, real[])
+real skew_normal_log(real, real, row_vector, real)
+real skew_normal_log(real, real, row_vector, vector)
+real skew_normal_log(real, real, row_vector, row_vector)
+real skew_normal_log(real, real, row_vector, real[])
+real skew_normal_log(real, real, real[], vector)
+real skew_normal_log(real, real, real[], row_vector)
+real skew_normal_log(real, vector, real, real)
+real skew_normal_log(real, vector, real, vector)
+real skew_normal_log(real, vector, real, row_vector)
+real skew_normal_log(real, vector, real, real[])
+real skew_normal_log(real, vector, vector, real)
+real skew_normal_log(real, vector, vector, vector)
+real skew_normal_log(real, vector, vector, row_vector)
+real skew_normal_log(real, vector, vector, real[])
+real skew_normal_log(real, vector, row_vector, real)
+real skew_normal_log(real, vector, row_vector, vector)
+real skew_normal_log(real, vector, row_vector, row_vector)
+real skew_normal_log(real, vector, row_vector, real[])
+real skew_normal_log(real, vector, real[], real)
+real skew_normal_log(real, vector, real[], vector)
+real skew_normal_log(real, vector, real[], row_vector)
+real skew_normal_log(real, vector, real[], real[])
+real skew_normal_log(real, row_vector, real, real)
+real skew_normal_log(real, row_vector, real, vector)
+real skew_normal_log(real, row_vector, real, row_vector)
+real skew_normal_log(real, row_vector, real, real[])
+real skew_normal_log(real, row_vector, vector, real)
+real skew_normal_log(real, row_vector, vector, vector)
+real skew_normal_log(real, row_vector, vector, row_vector)
+real skew_normal_log(real, row_vector, vector, real[])
+real skew_normal_log(real, row_vector, row_vector, real)
+real skew_normal_log(real, row_vector, row_vector, vector)
+real skew_normal_log(real, row_vector, row_vector, row_vector)
+real skew_normal_log(real, row_vector, row_vector, real[])
+real skew_normal_log(real, row_vector, real[], real)
+real skew_normal_log(real, row_vector, real[], vector)
+real skew_normal_log(real, row_vector, real[], row_vector)
+real skew_normal_log(real, row_vector, real[], real[])
+real skew_normal_log(real, real[], real, vector)
+real skew_normal_log(real, real[], real, row_vector)
+real skew_normal_log(real, real[], vector, real)
+real skew_normal_log(real, real[], vector, vector)
+real skew_normal_log(real, real[], vector, row_vector)
+real skew_normal_log(real, real[], vector, real[])
+real skew_normal_log(real, real[], row_vector, real)
+real skew_normal_log(real, real[], row_vector, vector)
+real skew_normal_log(real, real[], row_vector, row_vector)
+real skew_normal_log(real, real[], row_vector, real[])
+real skew_normal_log(real, real[], real[], vector)
+real skew_normal_log(real, real[], real[], row_vector)
+real skew_normal_log(vector, real, real, real)
+real skew_normal_log(vector, real, real, vector)
+real skew_normal_log(vector, real, real, row_vector)
+real skew_normal_log(vector, real, real, real[])
+real skew_normal_log(vector, real, vector, real)
+real skew_normal_log(vector, real, vector, vector)
+real skew_normal_log(vector, real, vector, row_vector)
+real skew_normal_log(vector, real, vector, real[])
+real skew_normal_log(vector, real, row_vector, real)
+real skew_normal_log(vector, real, row_vector, vector)
+real skew_normal_log(vector, real, row_vector, row_vector)
+real skew_normal_log(vector, real, row_vector, real[])
+real skew_normal_log(vector, real, real[], real)
+real skew_normal_log(vector, real, real[], vector)
+real skew_normal_log(vector, real, real[], row_vector)
+real skew_normal_log(vector, real, real[], real[])
+real skew_normal_log(vector, vector, real, real)
+real skew_normal_log(vector, vector, real, vector)
+real skew_normal_log(vector, vector, real, row_vector)
+real skew_normal_log(vector, vector, real, real[])
+real skew_normal_log(vector, vector, vector, real)
+real skew_normal_log(vector, vector, vector, vector)
+real skew_normal_log(vector, vector, vector, row_vector)
+real skew_normal_log(vector, vector, vector, real[])
+real skew_normal_log(vector, vector, row_vector, real)
+real skew_normal_log(vector, vector, row_vector, vector)
+real skew_normal_log(vector, vector, row_vector, row_vector)
+real skew_normal_log(vector, vector, row_vector, real[])
+real skew_normal_log(vector, vector, real[], real)
+real skew_normal_log(vector, vector, real[], vector)
+real skew_normal_log(vector, vector, real[], row_vector)
+real skew_normal_log(vector, vector, real[], real[])
+real skew_normal_log(vector, row_vector, real, real)
+real skew_normal_log(vector, row_vector, real, vector)
+real skew_normal_log(vector, row_vector, real, row_vector)
+real skew_normal_log(vector, row_vector, real, real[])
+real skew_normal_log(vector, row_vector, vector, real)
+real skew_normal_log(vector, row_vector, vector, vector)
+real skew_normal_log(vector, row_vector, vector, row_vector)
+real skew_normal_log(vector, row_vector, vector, real[])
+real skew_normal_log(vector, row_vector, row_vector, real)
+real skew_normal_log(vector, row_vector, row_vector, vector)
+real skew_normal_log(vector, row_vector, row_vector, row_vector)
+real skew_normal_log(vector, row_vector, row_vector, real[])
+real skew_normal_log(vector, row_vector, real[], real)
+real skew_normal_log(vector, row_vector, real[], vector)
+real skew_normal_log(vector, row_vector, real[], row_vector)
+real skew_normal_log(vector, row_vector, real[], real[])
+real skew_normal_log(vector, real[], real, real)
+real skew_normal_log(vector, real[], real, vector)
+real skew_normal_log(vector, real[], real, row_vector)
+real skew_normal_log(vector, real[], real, real[])
+real skew_normal_log(vector, real[], vector, real)
+real skew_normal_log(vector, real[], vector, vector)
+real skew_normal_log(vector, real[], vector, row_vector)
+real skew_normal_log(vector, real[], vector, real[])
+real skew_normal_log(vector, real[], row_vector, real)
+real skew_normal_log(vector, real[], row_vector, vector)
+real skew_normal_log(vector, real[], row_vector, row_vector)
+real skew_normal_log(vector, real[], row_vector, real[])
+real skew_normal_log(vector, real[], real[], real)
+real skew_normal_log(vector, real[], real[], vector)
+real skew_normal_log(vector, real[], real[], row_vector)
+real skew_normal_log(vector, real[], real[], real[])
+real skew_normal_log(row_vector, real, real, real)
+real skew_normal_log(row_vector, real, real, vector)
+real skew_normal_log(row_vector, real, real, row_vector)
+real skew_normal_log(row_vector, real, real, real[])
+real skew_normal_log(row_vector, real, vector, real)
+real skew_normal_log(row_vector, real, vector, vector)
+real skew_normal_log(row_vector, real, vector, row_vector)
+real skew_normal_log(row_vector, real, vector, real[])
+real skew_normal_log(row_vector, real, row_vector, real)
+real skew_normal_log(row_vector, real, row_vector, vector)
+real skew_normal_log(row_vector, real, row_vector, row_vector)
+real skew_normal_log(row_vector, real, row_vector, real[])
+real skew_normal_log(row_vector, real, real[], real)
+real skew_normal_log(row_vector, real, real[], vector)
+real skew_normal_log(row_vector, real, real[], row_vector)
+real skew_normal_log(row_vector, real, real[], real[])
+real skew_normal_log(row_vector, vector, real, real)
+real skew_normal_log(row_vector, vector, real, vector)
+real skew_normal_log(row_vector, vector, real, row_vector)
+real skew_normal_log(row_vector, vector, real, real[])
+real skew_normal_log(row_vector, vector, vector, real)
+real skew_normal_log(row_vector, vector, vector, vector)
+real skew_normal_log(row_vector, vector, vector, row_vector)
+real skew_normal_log(row_vector, vector, vector, real[])
+real skew_normal_log(row_vector, vector, row_vector, real)
+real skew_normal_log(row_vector, vector, row_vector, vector)
+real skew_normal_log(row_vector, vector, row_vector, row_vector)
+real skew_normal_log(row_vector, vector, row_vector, real[])
+real skew_normal_log(row_vector, vector, real[], real)
+real skew_normal_log(row_vector, vector, real[], vector)
+real skew_normal_log(row_vector, vector, real[], row_vector)
+real skew_normal_log(row_vector, vector, real[], real[])
+real skew_normal_log(row_vector, row_vector, real, real)
+real skew_normal_log(row_vector, row_vector, real, vector)
+real skew_normal_log(row_vector, row_vector, real, row_vector)
+real skew_normal_log(row_vector, row_vector, real, real[])
+real skew_normal_log(row_vector, row_vector, vector, real)
+real skew_normal_log(row_vector, row_vector, vector, vector)
+real skew_normal_log(row_vector, row_vector, vector, row_vector)
+real skew_normal_log(row_vector, row_vector, vector, real[])
+real skew_normal_log(row_vector, row_vector, row_vector, real)
+real skew_normal_log(row_vector, row_vector, row_vector, vector)
+real skew_normal_log(row_vector, row_vector, row_vector, row_vector)
+real skew_normal_log(row_vector, row_vector, row_vector, real[])
+real skew_normal_log(row_vector, row_vector, real[], real)
+real skew_normal_log(row_vector, row_vector, real[], vector)
+real skew_normal_log(row_vector, row_vector, real[], row_vector)
+real skew_normal_log(row_vector, row_vector, real[], real[])
+real skew_normal_log(row_vector, real[], real, real)
+real skew_normal_log(row_vector, real[], real, vector)
+real skew_normal_log(row_vector, real[], real, row_vector)
+real skew_normal_log(row_vector, real[], real, real[])
+real skew_normal_log(row_vector, real[], vector, real)
+real skew_normal_log(row_vector, real[], vector, vector)
+real skew_normal_log(row_vector, real[], vector, row_vector)
+real skew_normal_log(row_vector, real[], vector, real[])
+real skew_normal_log(row_vector, real[], row_vector, real)
+real skew_normal_log(row_vector, real[], row_vector, vector)
+real skew_normal_log(row_vector, real[], row_vector, row_vector)
+real skew_normal_log(row_vector, real[], row_vector, real[])
+real skew_normal_log(row_vector, real[], real[], real)
+real skew_normal_log(row_vector, real[], real[], vector)
+real skew_normal_log(row_vector, real[], real[], row_vector)
+real skew_normal_log(row_vector, real[], real[], real[])
+real skew_normal_log(real[], real, real, vector)
+real skew_normal_log(real[], real, real, row_vector)
+real skew_normal_log(real[], real, vector, real)
+real skew_normal_log(real[], real, vector, vector)
+real skew_normal_log(real[], real, vector, row_vector)
+real skew_normal_log(real[], real, vector, real[])
+real skew_normal_log(real[], real, row_vector, real)
+real skew_normal_log(real[], real, row_vector, vector)
+real skew_normal_log(real[], real, row_vector, row_vector)
+real skew_normal_log(real[], real, row_vector, real[])
+real skew_normal_log(real[], real, real[], vector)
+real skew_normal_log(real[], real, real[], row_vector)
+real skew_normal_log(real[], vector, real, real)
+real skew_normal_log(real[], vector, real, vector)
+real skew_normal_log(real[], vector, real, row_vector)
+real skew_normal_log(real[], vector, real, real[])
+real skew_normal_log(real[], vector, vector, real)
+real skew_normal_log(real[], vector, vector, vector)
+real skew_normal_log(real[], vector, vector, row_vector)
+real skew_normal_log(real[], vector, vector, real[])
+real skew_normal_log(real[], vector, row_vector, real)
+real skew_normal_log(real[], vector, row_vector, vector)
+real skew_normal_log(real[], vector, row_vector, row_vector)
+real skew_normal_log(real[], vector, row_vector, real[])
+real skew_normal_log(real[], vector, real[], real)
+real skew_normal_log(real[], vector, real[], vector)
+real skew_normal_log(real[], vector, real[], row_vector)
+real skew_normal_log(real[], vector, real[], real[])
+real skew_normal_log(real[], row_vector, real, real)
+real skew_normal_log(real[], row_vector, real, vector)
+real skew_normal_log(real[], row_vector, real, row_vector)
+real skew_normal_log(real[], row_vector, real, real[])
+real skew_normal_log(real[], row_vector, vector, real)
+real skew_normal_log(real[], row_vector, vector, vector)
+real skew_normal_log(real[], row_vector, vector, row_vector)
+real skew_normal_log(real[], row_vector, vector, real[])
+real skew_normal_log(real[], row_vector, row_vector, real)
+real skew_normal_log(real[], row_vector, row_vector, vector)
+real skew_normal_log(real[], row_vector, row_vector, row_vector)
+real skew_normal_log(real[], row_vector, row_vector, real[])
+real skew_normal_log(real[], row_vector, real[], real)
+real skew_normal_log(real[], row_vector, real[], vector)
+real skew_normal_log(real[], row_vector, real[], row_vector)
+real skew_normal_log(real[], row_vector, real[], real[])
+real skew_normal_log(real[], real[], real, vector)
+real skew_normal_log(real[], real[], real, row_vector)
+real skew_normal_log(real[], real[], vector, real)
+real skew_normal_log(real[], real[], vector, vector)
+real skew_normal_log(real[], real[], vector, row_vector)
+real skew_normal_log(real[], real[], vector, real[])
+real skew_normal_log(real[], real[], row_vector, real)
+real skew_normal_log(real[], real[], row_vector, vector)
+real skew_normal_log(real[], real[], row_vector, row_vector)
+real skew_normal_log(real[], real[], row_vector, real[])
+real skew_normal_log(real[], real[], real[], vector)
+real skew_normal_log(real[], real[], real[], row_vector)
+real skew_normal_lpdf(real, real, real, vector)
+real skew_normal_lpdf(real, real, real, row_vector)
+real skew_normal_lpdf(real, real, vector, real)
+real skew_normal_lpdf(real, real, vector, vector)
+real skew_normal_lpdf(real, real, vector, row_vector)
+real skew_normal_lpdf(real, real, vector, real[])
+real skew_normal_lpdf(real, real, row_vector, real)
+real skew_normal_lpdf(real, real, row_vector, vector)
+real skew_normal_lpdf(real, real, row_vector, row_vector)
+real skew_normal_lpdf(real, real, row_vector, real[])
+real skew_normal_lpdf(real, real, real[], vector)
+real skew_normal_lpdf(real, real, real[], row_vector)
+real skew_normal_lpdf(real, vector, real, real)
+real skew_normal_lpdf(real, vector, real, vector)
+real skew_normal_lpdf(real, vector, real, row_vector)
+real skew_normal_lpdf(real, vector, real, real[])
+real skew_normal_lpdf(real, vector, vector, real)
+real skew_normal_lpdf(real, vector, vector, vector)
+real skew_normal_lpdf(real, vector, vector, row_vector)
+real skew_normal_lpdf(real, vector, vector, real[])
+real skew_normal_lpdf(real, vector, row_vector, real)
+real skew_normal_lpdf(real, vector, row_vector, vector)
+real skew_normal_lpdf(real, vector, row_vector, row_vector)
+real skew_normal_lpdf(real, vector, row_vector, real[])
+real skew_normal_lpdf(real, vector, real[], real)
+real skew_normal_lpdf(real, vector, real[], vector)
+real skew_normal_lpdf(real, vector, real[], row_vector)
+real skew_normal_lpdf(real, vector, real[], real[])
+real skew_normal_lpdf(real, row_vector, real, real)
+real skew_normal_lpdf(real, row_vector, real, vector)
+real skew_normal_lpdf(real, row_vector, real, row_vector)
+real skew_normal_lpdf(real, row_vector, real, real[])
+real skew_normal_lpdf(real, row_vector, vector, real)
+real skew_normal_lpdf(real, row_vector, vector, vector)
+real skew_normal_lpdf(real, row_vector, vector, row_vector)
+real skew_normal_lpdf(real, row_vector, vector, real[])
+real skew_normal_lpdf(real, row_vector, row_vector, real)
+real skew_normal_lpdf(real, row_vector, row_vector, vector)
+real skew_normal_lpdf(real, row_vector, row_vector, row_vector)
+real skew_normal_lpdf(real, row_vector, row_vector, real[])
+real skew_normal_lpdf(real, row_vector, real[], real)
+real skew_normal_lpdf(real, row_vector, real[], vector)
+real skew_normal_lpdf(real, row_vector, real[], row_vector)
+real skew_normal_lpdf(real, row_vector, real[], real[])
+real skew_normal_lpdf(real, real[], real, vector)
+real skew_normal_lpdf(real, real[], real, row_vector)
+real skew_normal_lpdf(real, real[], vector, real)
+real skew_normal_lpdf(real, real[], vector, vector)
+real skew_normal_lpdf(real, real[], vector, row_vector)
+real skew_normal_lpdf(real, real[], vector, real[])
+real skew_normal_lpdf(real, real[], row_vector, real)
+real skew_normal_lpdf(real, real[], row_vector, vector)
+real skew_normal_lpdf(real, real[], row_vector, row_vector)
+real skew_normal_lpdf(real, real[], row_vector, real[])
+real skew_normal_lpdf(real, real[], real[], vector)
+real skew_normal_lpdf(real, real[], real[], row_vector)
+real skew_normal_lpdf(vector, real, real, real)
+real skew_normal_lpdf(vector, real, real, vector)
+real skew_normal_lpdf(vector, real, real, row_vector)
+real skew_normal_lpdf(vector, real, real, real[])
+real skew_normal_lpdf(vector, real, vector, real)
+real skew_normal_lpdf(vector, real, vector, vector)
+real skew_normal_lpdf(vector, real, vector, row_vector)
+real skew_normal_lpdf(vector, real, vector, real[])
+real skew_normal_lpdf(vector, real, row_vector, real)
+real skew_normal_lpdf(vector, real, row_vector, vector)
+real skew_normal_lpdf(vector, real, row_vector, row_vector)
+real skew_normal_lpdf(vector, real, row_vector, real[])
+real skew_normal_lpdf(vector, real, real[], real)
+real skew_normal_lpdf(vector, real, real[], vector)
+real skew_normal_lpdf(vector, real, real[], row_vector)
+real skew_normal_lpdf(vector, real, real[], real[])
+real skew_normal_lpdf(vector, vector, real, real)
+real skew_normal_lpdf(vector, vector, real, vector)
+real skew_normal_lpdf(vector, vector, real, row_vector)
+real skew_normal_lpdf(vector, vector, real, real[])
+real skew_normal_lpdf(vector, vector, vector, real)
+real skew_normal_lpdf(vector, vector, vector, vector)
+real skew_normal_lpdf(vector, vector, vector, row_vector)
+real skew_normal_lpdf(vector, vector, vector, real[])
+real skew_normal_lpdf(vector, vector, row_vector, real)
+real skew_normal_lpdf(vector, vector, row_vector, vector)
+real skew_normal_lpdf(vector, vector, row_vector, row_vector)
+real skew_normal_lpdf(vector, vector, row_vector, real[])
+real skew_normal_lpdf(vector, vector, real[], real)
+real skew_normal_lpdf(vector, vector, real[], vector)
+real skew_normal_lpdf(vector, vector, real[], row_vector)
+real skew_normal_lpdf(vector, vector, real[], real[])
+real skew_normal_lpdf(vector, row_vector, real, real)
+real skew_normal_lpdf(vector, row_vector, real, vector)
+real skew_normal_lpdf(vector, row_vector, real, row_vector)
+real skew_normal_lpdf(vector, row_vector, real, real[])
+real skew_normal_lpdf(vector, row_vector, vector, real)
+real skew_normal_lpdf(vector, row_vector, vector, vector)
+real skew_normal_lpdf(vector, row_vector, vector, row_vector)
+real skew_normal_lpdf(vector, row_vector, vector, real[])
+real skew_normal_lpdf(vector, row_vector, row_vector, real)
+real skew_normal_lpdf(vector, row_vector, row_vector, vector)
+real skew_normal_lpdf(vector, row_vector, row_vector, row_vector)
+real skew_normal_lpdf(vector, row_vector, row_vector, real[])
+real skew_normal_lpdf(vector, row_vector, real[], real)
+real skew_normal_lpdf(vector, row_vector, real[], vector)
+real skew_normal_lpdf(vector, row_vector, real[], row_vector)
+real skew_normal_lpdf(vector, row_vector, real[], real[])
+real skew_normal_lpdf(vector, real[], real, real)
+real skew_normal_lpdf(vector, real[], real, vector)
+real skew_normal_lpdf(vector, real[], real, row_vector)
+real skew_normal_lpdf(vector, real[], real, real[])
+real skew_normal_lpdf(vector, real[], vector, real)
+real skew_normal_lpdf(vector, real[], vector, vector)
+real skew_normal_lpdf(vector, real[], vector, row_vector)
+real skew_normal_lpdf(vector, real[], vector, real[])
+real skew_normal_lpdf(vector, real[], row_vector, real)
+real skew_normal_lpdf(vector, real[], row_vector, vector)
+real skew_normal_lpdf(vector, real[], row_vector, row_vector)
+real skew_normal_lpdf(vector, real[], row_vector, real[])
+real skew_normal_lpdf(vector, real[], real[], real)
+real skew_normal_lpdf(vector, real[], real[], vector)
+real skew_normal_lpdf(vector, real[], real[], row_vector)
+real skew_normal_lpdf(vector, real[], real[], real[])
+real skew_normal_lpdf(row_vector, real, real, real)
+real skew_normal_lpdf(row_vector, real, real, vector)
+real skew_normal_lpdf(row_vector, real, real, row_vector)
+real skew_normal_lpdf(row_vector, real, real, real[])
+real skew_normal_lpdf(row_vector, real, vector, real)
+real skew_normal_lpdf(row_vector, real, vector, vector)
+real skew_normal_lpdf(row_vector, real, vector, row_vector)
+real skew_normal_lpdf(row_vector, real, vector, real[])
+real skew_normal_lpdf(row_vector, real, row_vector, real)
+real skew_normal_lpdf(row_vector, real, row_vector, vector)
+real skew_normal_lpdf(row_vector, real, row_vector, row_vector)
+real skew_normal_lpdf(row_vector, real, row_vector, real[])
+real skew_normal_lpdf(row_vector, real, real[], real)
+real skew_normal_lpdf(row_vector, real, real[], vector)
+real skew_normal_lpdf(row_vector, real, real[], row_vector)
+real skew_normal_lpdf(row_vector, real, real[], real[])
+real skew_normal_lpdf(row_vector, vector, real, real)
+real skew_normal_lpdf(row_vector, vector, real, vector)
+real skew_normal_lpdf(row_vector, vector, real, row_vector)
+real skew_normal_lpdf(row_vector, vector, real, real[])
+real skew_normal_lpdf(row_vector, vector, vector, real)
+real skew_normal_lpdf(row_vector, vector, vector, vector)
+real skew_normal_lpdf(row_vector, vector, vector, row_vector)
+real skew_normal_lpdf(row_vector, vector, vector, real[])
+real skew_normal_lpdf(row_vector, vector, row_vector, real)
+real skew_normal_lpdf(row_vector, vector, row_vector, vector)
+real skew_normal_lpdf(row_vector, vector, row_vector, row_vector)
+real skew_normal_lpdf(row_vector, vector, row_vector, real[])
+real skew_normal_lpdf(row_vector, vector, real[], real)
+real skew_normal_lpdf(row_vector, vector, real[], vector)
+real skew_normal_lpdf(row_vector, vector, real[], row_vector)
+real skew_normal_lpdf(row_vector, vector, real[], real[])
+real skew_normal_lpdf(row_vector, row_vector, real, real)
+real skew_normal_lpdf(row_vector, row_vector, real, vector)
+real skew_normal_lpdf(row_vector, row_vector, real, row_vector)
+real skew_normal_lpdf(row_vector, row_vector, real, real[])
+real skew_normal_lpdf(row_vector, row_vector, vector, real)
+real skew_normal_lpdf(row_vector, row_vector, vector, vector)
+real skew_normal_lpdf(row_vector, row_vector, vector, row_vector)
+real skew_normal_lpdf(row_vector, row_vector, vector, real[])
+real skew_normal_lpdf(row_vector, row_vector, row_vector, real)
+real skew_normal_lpdf(row_vector, row_vector, row_vector, vector)
+real skew_normal_lpdf(row_vector, row_vector, row_vector, row_vector)
+real skew_normal_lpdf(row_vector, row_vector, row_vector, real[])
+real skew_normal_lpdf(row_vector, row_vector, real[], real)
+real skew_normal_lpdf(row_vector, row_vector, real[], vector)
+real skew_normal_lpdf(row_vector, row_vector, real[], row_vector)
+real skew_normal_lpdf(row_vector, row_vector, real[], real[])
+real skew_normal_lpdf(row_vector, real[], real, real)
+real skew_normal_lpdf(row_vector, real[], real, vector)
+real skew_normal_lpdf(row_vector, real[], real, row_vector)
+real skew_normal_lpdf(row_vector, real[], real, real[])
+real skew_normal_lpdf(row_vector, real[], vector, real)
+real skew_normal_lpdf(row_vector, real[], vector, vector)
+real skew_normal_lpdf(row_vector, real[], vector, row_vector)
+real skew_normal_lpdf(row_vector, real[], vector, real[])
+real skew_normal_lpdf(row_vector, real[], row_vector, real)
+real skew_normal_lpdf(row_vector, real[], row_vector, vector)
+real skew_normal_lpdf(row_vector, real[], row_vector, row_vector)
+real skew_normal_lpdf(row_vector, real[], row_vector, real[])
+real skew_normal_lpdf(row_vector, real[], real[], real)
+real skew_normal_lpdf(row_vector, real[], real[], vector)
+real skew_normal_lpdf(row_vector, real[], real[], row_vector)
+real skew_normal_lpdf(row_vector, real[], real[], real[])
+real skew_normal_lpdf(real[], real, real, vector)
+real skew_normal_lpdf(real[], real, real, row_vector)
+real skew_normal_lpdf(real[], real, vector, real)
+real skew_normal_lpdf(real[], real, vector, vector)
+real skew_normal_lpdf(real[], real, vector, row_vector)
+real skew_normal_lpdf(real[], real, vector, real[])
+real skew_normal_lpdf(real[], real, row_vector, real)
+real skew_normal_lpdf(real[], real, row_vector, vector)
+real skew_normal_lpdf(real[], real, row_vector, row_vector)
+real skew_normal_lpdf(real[], real, row_vector, real[])
+real skew_normal_lpdf(real[], real, real[], vector)
+real skew_normal_lpdf(real[], real, real[], row_vector)
+real skew_normal_lpdf(real[], vector, real, real)
+real skew_normal_lpdf(real[], vector, real, vector)
+real skew_normal_lpdf(real[], vector, real, row_vector)
+real skew_normal_lpdf(real[], vector, real, real[])
+real skew_normal_lpdf(real[], vector, vector, real)
+real skew_normal_lpdf(real[], vector, vector, vector)
+real skew_normal_lpdf(real[], vector, vector, row_vector)
+real skew_normal_lpdf(real[], vector, vector, real[])
+real skew_normal_lpdf(real[], vector, row_vector, real)
+real skew_normal_lpdf(real[], vector, row_vector, vector)
+real skew_normal_lpdf(real[], vector, row_vector, row_vector)
+real skew_normal_lpdf(real[], vector, row_vector, real[])
+real skew_normal_lpdf(real[], vector, real[], real)
+real skew_normal_lpdf(real[], vector, real[], vector)
+real skew_normal_lpdf(real[], vector, real[], row_vector)
+real skew_normal_lpdf(real[], vector, real[], real[])
+real skew_normal_lpdf(real[], row_vector, real, real)
+real skew_normal_lpdf(real[], row_vector, real, vector)
+real skew_normal_lpdf(real[], row_vector, real, row_vector)
+real skew_normal_lpdf(real[], row_vector, real, real[])
+real skew_normal_lpdf(real[], row_vector, vector, real)
+real skew_normal_lpdf(real[], row_vector, vector, vector)
+real skew_normal_lpdf(real[], row_vector, vector, row_vector)
+real skew_normal_lpdf(real[], row_vector, vector, real[])
+real skew_normal_lpdf(real[], row_vector, row_vector, real)
+real skew_normal_lpdf(real[], row_vector, row_vector, vector)
+real skew_normal_lpdf(real[], row_vector, row_vector, row_vector)
+real skew_normal_lpdf(real[], row_vector, row_vector, real[])
+real skew_normal_lpdf(real[], row_vector, real[], real)
+real skew_normal_lpdf(real[], row_vector, real[], vector)
+real skew_normal_lpdf(real[], row_vector, real[], row_vector)
+real skew_normal_lpdf(real[], row_vector, real[], real[])
+real skew_normal_lpdf(real[], real[], real, vector)
+real skew_normal_lpdf(real[], real[], real, row_vector)
+real skew_normal_lpdf(real[], real[], vector, real)
+real skew_normal_lpdf(real[], real[], vector, vector)
+real skew_normal_lpdf(real[], real[], vector, row_vector)
+real skew_normal_lpdf(real[], real[], vector, real[])
+real skew_normal_lpdf(real[], real[], row_vector, real)
+real skew_normal_lpdf(real[], real[], row_vector, vector)
+real skew_normal_lpdf(real[], real[], row_vector, row_vector)
+real skew_normal_lpdf(real[], real[], row_vector, real[])
+real skew_normal_lpdf(real[], real[], real[], vector)
+real skew_normal_lpdf(real[], real[], real[], row_vector)
+real[] skew_normal_rng(int, int, vector)
+real[] skew_normal_rng(int, int, row_vector)
+real[] skew_normal_rng(int, real, vector)
+real[] skew_normal_rng(int, real, row_vector)
+real[] skew_normal_rng(int, vector, int)
+real[] skew_normal_rng(int, vector, real)
+real[] skew_normal_rng(int, vector, vector)
+real[] skew_normal_rng(int, vector, row_vector)
+real[] skew_normal_rng(int, vector, int[])
+real[] skew_normal_rng(int, vector, real[])
+real[] skew_normal_rng(int, row_vector, int)
+real[] skew_normal_rng(int, row_vector, real)
+real[] skew_normal_rng(int, row_vector, vector)
+real[] skew_normal_rng(int, row_vector, row_vector)
+real[] skew_normal_rng(int, row_vector, int[])
+real[] skew_normal_rng(int, row_vector, real[])
+real[] skew_normal_rng(int, int[], vector)
+real[] skew_normal_rng(int, int[], row_vector)
+real[] skew_normal_rng(int, real[], vector)
+real[] skew_normal_rng(int, real[], row_vector)
+real[] skew_normal_rng(real, int, vector)
+real[] skew_normal_rng(real, int, row_vector)
+real[] skew_normal_rng(real, real, vector)
+real[] skew_normal_rng(real, real, row_vector)
+real[] skew_normal_rng(real, vector, int)
+real[] skew_normal_rng(real, vector, real)
+real[] skew_normal_rng(real, vector, vector)
+real[] skew_normal_rng(real, vector, row_vector)
+real[] skew_normal_rng(real, vector, int[])
+real[] skew_normal_rng(real, vector, real[])
+real[] skew_normal_rng(real, row_vector, int)
+real[] skew_normal_rng(real, row_vector, real)
+real[] skew_normal_rng(real, row_vector, vector)
+real[] skew_normal_rng(real, row_vector, row_vector)
+real[] skew_normal_rng(real, row_vector, int[])
+real[] skew_normal_rng(real, row_vector, real[])
+real[] skew_normal_rng(real, int[], vector)
+real[] skew_normal_rng(real, int[], row_vector)
+real[] skew_normal_rng(real, real[], vector)
+real[] skew_normal_rng(real, real[], row_vector)
+real[] skew_normal_rng(vector, int, int)
+real[] skew_normal_rng(vector, int, real)
+real[] skew_normal_rng(vector, int, vector)
+real[] skew_normal_rng(vector, int, row_vector)
+real[] skew_normal_rng(vector, int, int[])
+real[] skew_normal_rng(vector, int, real[])
+real[] skew_normal_rng(vector, real, int)
+real[] skew_normal_rng(vector, real, real)
+real[] skew_normal_rng(vector, real, vector)
+real[] skew_normal_rng(vector, real, row_vector)
+real[] skew_normal_rng(vector, real, int[])
+real[] skew_normal_rng(vector, real, real[])
+real[] skew_normal_rng(vector, vector, int)
+real[] skew_normal_rng(vector, vector, real)
+real[] skew_normal_rng(vector, vector, vector)
+real[] skew_normal_rng(vector, vector, row_vector)
+real[] skew_normal_rng(vector, vector, int[])
+real[] skew_normal_rng(vector, vector, real[])
+real[] skew_normal_rng(vector, row_vector, int)
+real[] skew_normal_rng(vector, row_vector, real)
+real[] skew_normal_rng(vector, row_vector, vector)
+real[] skew_normal_rng(vector, row_vector, row_vector)
+real[] skew_normal_rng(vector, row_vector, int[])
+real[] skew_normal_rng(vector, row_vector, real[])
+real[] skew_normal_rng(vector, int[], int)
+real[] skew_normal_rng(vector, int[], real)
+real[] skew_normal_rng(vector, int[], vector)
+real[] skew_normal_rng(vector, int[], row_vector)
+real[] skew_normal_rng(vector, int[], int[])
+real[] skew_normal_rng(vector, int[], real[])
+real[] skew_normal_rng(vector, real[], int)
+real[] skew_normal_rng(vector, real[], real)
+real[] skew_normal_rng(vector, real[], vector)
+real[] skew_normal_rng(vector, real[], row_vector)
+real[] skew_normal_rng(vector, real[], int[])
+real[] skew_normal_rng(vector, real[], real[])
+real[] skew_normal_rng(row_vector, int, int)
+real[] skew_normal_rng(row_vector, int, real)
+real[] skew_normal_rng(row_vector, int, vector)
+real[] skew_normal_rng(row_vector, int, row_vector)
+real[] skew_normal_rng(row_vector, int, int[])
+real[] skew_normal_rng(row_vector, int, real[])
+real[] skew_normal_rng(row_vector, real, int)
+real[] skew_normal_rng(row_vector, real, real)
+real[] skew_normal_rng(row_vector, real, vector)
+real[] skew_normal_rng(row_vector, real, row_vector)
+real[] skew_normal_rng(row_vector, real, int[])
+real[] skew_normal_rng(row_vector, real, real[])
+real[] skew_normal_rng(row_vector, vector, int)
+real[] skew_normal_rng(row_vector, vector, real)
+real[] skew_normal_rng(row_vector, vector, vector)
+real[] skew_normal_rng(row_vector, vector, row_vector)
+real[] skew_normal_rng(row_vector, vector, int[])
+real[] skew_normal_rng(row_vector, vector, real[])
+real[] skew_normal_rng(row_vector, row_vector, int)
+real[] skew_normal_rng(row_vector, row_vector, real)
+real[] skew_normal_rng(row_vector, row_vector, vector)
+real[] skew_normal_rng(row_vector, row_vector, row_vector)
+real[] skew_normal_rng(row_vector, row_vector, int[])
+real[] skew_normal_rng(row_vector, row_vector, real[])
+real[] skew_normal_rng(row_vector, int[], int)
+real[] skew_normal_rng(row_vector, int[], real)
+real[] skew_normal_rng(row_vector, int[], vector)
+real[] skew_normal_rng(row_vector, int[], row_vector)
+real[] skew_normal_rng(row_vector, int[], int[])
+real[] skew_normal_rng(row_vector, int[], real[])
+real[] skew_normal_rng(row_vector, real[], int)
+real[] skew_normal_rng(row_vector, real[], real)
+real[] skew_normal_rng(row_vector, real[], vector)
+real[] skew_normal_rng(row_vector, real[], row_vector)
+real[] skew_normal_rng(row_vector, real[], int[])
+real[] skew_normal_rng(row_vector, real[], real[])
+real[] skew_normal_rng(int[], int, vector)
+real[] skew_normal_rng(int[], int, row_vector)
+real[] skew_normal_rng(int[], real, vector)
+real[] skew_normal_rng(int[], real, row_vector)
+real[] skew_normal_rng(int[], vector, int)
+real[] skew_normal_rng(int[], vector, real)
+real[] skew_normal_rng(int[], vector, vector)
+real[] skew_normal_rng(int[], vector, row_vector)
+real[] skew_normal_rng(int[], vector, int[])
+real[] skew_normal_rng(int[], vector, real[])
+real[] skew_normal_rng(int[], row_vector, int)
+real[] skew_normal_rng(int[], row_vector, real)
+real[] skew_normal_rng(int[], row_vector, vector)
+real[] skew_normal_rng(int[], row_vector, row_vector)
+real[] skew_normal_rng(int[], row_vector, int[])
+real[] skew_normal_rng(int[], row_vector, real[])
+real[] skew_normal_rng(int[], int[], vector)
+real[] skew_normal_rng(int[], int[], row_vector)
+real[] skew_normal_rng(int[], real[], vector)
+real[] skew_normal_rng(int[], real[], row_vector)
+real[] skew_normal_rng(real[], int, vector)
+real[] skew_normal_rng(real[], int, row_vector)
+real[] skew_normal_rng(real[], real, vector)
+real[] skew_normal_rng(real[], real, row_vector)
+real[] skew_normal_rng(real[], vector, int)
+real[] skew_normal_rng(real[], vector, real)
+real[] skew_normal_rng(real[], vector, vector)
+real[] skew_normal_rng(real[], vector, row_vector)
+real[] skew_normal_rng(real[], vector, int[])
+real[] skew_normal_rng(real[], vector, real[])
+real[] skew_normal_rng(real[], row_vector, int)
+real[] skew_normal_rng(real[], row_vector, real)
+real[] skew_normal_rng(real[], row_vector, vector)
+real[] skew_normal_rng(real[], row_vector, row_vector)
+real[] skew_normal_rng(real[], row_vector, int[])
+real[] skew_normal_rng(real[], row_vector, real[])
+real[] skew_normal_rng(real[], int[], vector)
+real[] skew_normal_rng(real[], int[], row_vector)
+real[] skew_normal_rng(real[], real[], vector)
+real[] skew_normal_rng(real[], real[], row_vector)
+real std_normal_ccdf_log(vector)
+real std_normal_ccdf_log(row_vector)
+real std_normal_cdf(vector)
+real std_normal_cdf(row_vector)
+real std_normal_cdf_log(vector)
+real std_normal_cdf_log(row_vector)
+real std_normal_lccdf(vector)
+real std_normal_lccdf(row_vector)
+real std_normal_lcdf(vector)
+real std_normal_lcdf(row_vector)
+real std_normal_log(vector)
+real std_normal_log(row_vector)
+real std_normal_lpdf(vector)
+real std_normal_lpdf(row_vector)
+real student_t_ccdf_log(real, real, real, vector)
+real student_t_ccdf_log(real, real, real, row_vector)
+real student_t_ccdf_log(real, real, vector, real)
+real student_t_ccdf_log(real, real, vector, vector)
+real student_t_ccdf_log(real, real, vector, row_vector)
+real student_t_ccdf_log(real, real, vector, real[])
+real student_t_ccdf_log(real, real, row_vector, real)
+real student_t_ccdf_log(real, real, row_vector, vector)
+real student_t_ccdf_log(real, real, row_vector, row_vector)
+real student_t_ccdf_log(real, real, row_vector, real[])
+real student_t_ccdf_log(real, real, real[], vector)
+real student_t_ccdf_log(real, real, real[], row_vector)
+real student_t_ccdf_log(real, vector, real, real)
+real student_t_ccdf_log(real, vector, real, vector)
+real student_t_ccdf_log(real, vector, real, row_vector)
+real student_t_ccdf_log(real, vector, real, real[])
+real student_t_ccdf_log(real, vector, vector, real)
+real student_t_ccdf_log(real, vector, vector, vector)
+real student_t_ccdf_log(real, vector, vector, row_vector)
+real student_t_ccdf_log(real, vector, vector, real[])
+real student_t_ccdf_log(real, vector, row_vector, real)
+real student_t_ccdf_log(real, vector, row_vector, vector)
+real student_t_ccdf_log(real, vector, row_vector, row_vector)
+real student_t_ccdf_log(real, vector, row_vector, real[])
+real student_t_ccdf_log(real, vector, real[], real)
+real student_t_ccdf_log(real, vector, real[], vector)
+real student_t_ccdf_log(real, vector, real[], row_vector)
+real student_t_ccdf_log(real, vector, real[], real[])
+real student_t_ccdf_log(real, row_vector, real, real)
+real student_t_ccdf_log(real, row_vector, real, vector)
+real student_t_ccdf_log(real, row_vector, real, row_vector)
+real student_t_ccdf_log(real, row_vector, real, real[])
+real student_t_ccdf_log(real, row_vector, vector, real)
+real student_t_ccdf_log(real, row_vector, vector, vector)
+real student_t_ccdf_log(real, row_vector, vector, row_vector)
+real student_t_ccdf_log(real, row_vector, vector, real[])
+real student_t_ccdf_log(real, row_vector, row_vector, real)
+real student_t_ccdf_log(real, row_vector, row_vector, vector)
+real student_t_ccdf_log(real, row_vector, row_vector, row_vector)
+real student_t_ccdf_log(real, row_vector, row_vector, real[])
+real student_t_ccdf_log(real, row_vector, real[], real)
+real student_t_ccdf_log(real, row_vector, real[], vector)
+real student_t_ccdf_log(real, row_vector, real[], row_vector)
+real student_t_ccdf_log(real, row_vector, real[], real[])
+real student_t_ccdf_log(real, real[], real, vector)
+real student_t_ccdf_log(real, real[], real, row_vector)
+real student_t_ccdf_log(real, real[], vector, real)
+real student_t_ccdf_log(real, real[], vector, vector)
+real student_t_ccdf_log(real, real[], vector, row_vector)
+real student_t_ccdf_log(real, real[], vector, real[])
+real student_t_ccdf_log(real, real[], row_vector, real)
+real student_t_ccdf_log(real, real[], row_vector, vector)
+real student_t_ccdf_log(real, real[], row_vector, row_vector)
+real student_t_ccdf_log(real, real[], row_vector, real[])
+real student_t_ccdf_log(real, real[], real[], vector)
+real student_t_ccdf_log(real, real[], real[], row_vector)
+real student_t_ccdf_log(vector, real, real, real)
+real student_t_ccdf_log(vector, real, real, vector)
+real student_t_ccdf_log(vector, real, real, row_vector)
+real student_t_ccdf_log(vector, real, real, real[])
+real student_t_ccdf_log(vector, real, vector, real)
+real student_t_ccdf_log(vector, real, vector, vector)
+real student_t_ccdf_log(vector, real, vector, row_vector)
+real student_t_ccdf_log(vector, real, vector, real[])
+real student_t_ccdf_log(vector, real, row_vector, real)
+real student_t_ccdf_log(vector, real, row_vector, vector)
+real student_t_ccdf_log(vector, real, row_vector, row_vector)
+real student_t_ccdf_log(vector, real, row_vector, real[])
+real student_t_ccdf_log(vector, real, real[], real)
+real student_t_ccdf_log(vector, real, real[], vector)
+real student_t_ccdf_log(vector, real, real[], row_vector)
+real student_t_ccdf_log(vector, real, real[], real[])
+real student_t_ccdf_log(vector, vector, real, real)
+real student_t_ccdf_log(vector, vector, real, vector)
+real student_t_ccdf_log(vector, vector, real, row_vector)
+real student_t_ccdf_log(vector, vector, real, real[])
+real student_t_ccdf_log(vector, vector, vector, real)
+real student_t_ccdf_log(vector, vector, vector, vector)
+real student_t_ccdf_log(vector, vector, vector, row_vector)
+real student_t_ccdf_log(vector, vector, vector, real[])
+real student_t_ccdf_log(vector, vector, row_vector, real)
+real student_t_ccdf_log(vector, vector, row_vector, vector)
+real student_t_ccdf_log(vector, vector, row_vector, row_vector)
+real student_t_ccdf_log(vector, vector, row_vector, real[])
+real student_t_ccdf_log(vector, vector, real[], real)
+real student_t_ccdf_log(vector, vector, real[], vector)
+real student_t_ccdf_log(vector, vector, real[], row_vector)
+real student_t_ccdf_log(vector, vector, real[], real[])
+real student_t_ccdf_log(vector, row_vector, real, real)
+real student_t_ccdf_log(vector, row_vector, real, vector)
+real student_t_ccdf_log(vector, row_vector, real, row_vector)
+real student_t_ccdf_log(vector, row_vector, real, real[])
+real student_t_ccdf_log(vector, row_vector, vector, real)
+real student_t_ccdf_log(vector, row_vector, vector, vector)
+real student_t_ccdf_log(vector, row_vector, vector, row_vector)
+real student_t_ccdf_log(vector, row_vector, vector, real[])
+real student_t_ccdf_log(vector, row_vector, row_vector, real)
+real student_t_ccdf_log(vector, row_vector, row_vector, vector)
+real student_t_ccdf_log(vector, row_vector, row_vector, row_vector)
+real student_t_ccdf_log(vector, row_vector, row_vector, real[])
+real student_t_ccdf_log(vector, row_vector, real[], real)
+real student_t_ccdf_log(vector, row_vector, real[], vector)
+real student_t_ccdf_log(vector, row_vector, real[], row_vector)
+real student_t_ccdf_log(vector, row_vector, real[], real[])
+real student_t_ccdf_log(vector, real[], real, real)
+real student_t_ccdf_log(vector, real[], real, vector)
+real student_t_ccdf_log(vector, real[], real, row_vector)
+real student_t_ccdf_log(vector, real[], real, real[])
+real student_t_ccdf_log(vector, real[], vector, real)
+real student_t_ccdf_log(vector, real[], vector, vector)
+real student_t_ccdf_log(vector, real[], vector, row_vector)
+real student_t_ccdf_log(vector, real[], vector, real[])
+real student_t_ccdf_log(vector, real[], row_vector, real)
+real student_t_ccdf_log(vector, real[], row_vector, vector)
+real student_t_ccdf_log(vector, real[], row_vector, row_vector)
+real student_t_ccdf_log(vector, real[], row_vector, real[])
+real student_t_ccdf_log(vector, real[], real[], real)
+real student_t_ccdf_log(vector, real[], real[], vector)
+real student_t_ccdf_log(vector, real[], real[], row_vector)
+real student_t_ccdf_log(vector, real[], real[], real[])
+real student_t_ccdf_log(row_vector, real, real, real)
+real student_t_ccdf_log(row_vector, real, real, vector)
+real student_t_ccdf_log(row_vector, real, real, row_vector)
+real student_t_ccdf_log(row_vector, real, real, real[])
+real student_t_ccdf_log(row_vector, real, vector, real)
+real student_t_ccdf_log(row_vector, real, vector, vector)
+real student_t_ccdf_log(row_vector, real, vector, row_vector)
+real student_t_ccdf_log(row_vector, real, vector, real[])
+real student_t_ccdf_log(row_vector, real, row_vector, real)
+real student_t_ccdf_log(row_vector, real, row_vector, vector)
+real student_t_ccdf_log(row_vector, real, row_vector, row_vector)
+real student_t_ccdf_log(row_vector, real, row_vector, real[])
+real student_t_ccdf_log(row_vector, real, real[], real)
+real student_t_ccdf_log(row_vector, real, real[], vector)
+real student_t_ccdf_log(row_vector, real, real[], row_vector)
+real student_t_ccdf_log(row_vector, real, real[], real[])
+real student_t_ccdf_log(row_vector, vector, real, real)
+real student_t_ccdf_log(row_vector, vector, real, vector)
+real student_t_ccdf_log(row_vector, vector, real, row_vector)
+real student_t_ccdf_log(row_vector, vector, real, real[])
+real student_t_ccdf_log(row_vector, vector, vector, real)
+real student_t_ccdf_log(row_vector, vector, vector, vector)
+real student_t_ccdf_log(row_vector, vector, vector, row_vector)
+real student_t_ccdf_log(row_vector, vector, vector, real[])
+real student_t_ccdf_log(row_vector, vector, row_vector, real)
+real student_t_ccdf_log(row_vector, vector, row_vector, vector)
+real student_t_ccdf_log(row_vector, vector, row_vector, row_vector)
+real student_t_ccdf_log(row_vector, vector, row_vector, real[])
+real student_t_ccdf_log(row_vector, vector, real[], real)
+real student_t_ccdf_log(row_vector, vector, real[], vector)
+real student_t_ccdf_log(row_vector, vector, real[], row_vector)
+real student_t_ccdf_log(row_vector, vector, real[], real[])
+real student_t_ccdf_log(row_vector, row_vector, real, real)
+real student_t_ccdf_log(row_vector, row_vector, real, vector)
+real student_t_ccdf_log(row_vector, row_vector, real, row_vector)
+real student_t_ccdf_log(row_vector, row_vector, real, real[])
+real student_t_ccdf_log(row_vector, row_vector, vector, real)
+real student_t_ccdf_log(row_vector, row_vector, vector, vector)
+real student_t_ccdf_log(row_vector, row_vector, vector, row_vector)
+real student_t_ccdf_log(row_vector, row_vector, vector, real[])
+real student_t_ccdf_log(row_vector, row_vector, row_vector, real)
+real student_t_ccdf_log(row_vector, row_vector, row_vector, vector)
+real student_t_ccdf_log(row_vector, row_vector, row_vector, row_vector)
+real student_t_ccdf_log(row_vector, row_vector, row_vector, real[])
+real student_t_ccdf_log(row_vector, row_vector, real[], real)
+real student_t_ccdf_log(row_vector, row_vector, real[], vector)
+real student_t_ccdf_log(row_vector, row_vector, real[], row_vector)
+real student_t_ccdf_log(row_vector, row_vector, real[], real[])
+real student_t_ccdf_log(row_vector, real[], real, real)
+real student_t_ccdf_log(row_vector, real[], real, vector)
+real student_t_ccdf_log(row_vector, real[], real, row_vector)
+real student_t_ccdf_log(row_vector, real[], real, real[])
+real student_t_ccdf_log(row_vector, real[], vector, real)
+real student_t_ccdf_log(row_vector, real[], vector, vector)
+real student_t_ccdf_log(row_vector, real[], vector, row_vector)
+real student_t_ccdf_log(row_vector, real[], vector, real[])
+real student_t_ccdf_log(row_vector, real[], row_vector, real)
+real student_t_ccdf_log(row_vector, real[], row_vector, vector)
+real student_t_ccdf_log(row_vector, real[], row_vector, row_vector)
+real student_t_ccdf_log(row_vector, real[], row_vector, real[])
+real student_t_ccdf_log(row_vector, real[], real[], real)
+real student_t_ccdf_log(row_vector, real[], real[], vector)
+real student_t_ccdf_log(row_vector, real[], real[], row_vector)
+real student_t_ccdf_log(row_vector, real[], real[], real[])
+real student_t_ccdf_log(real[], real, real, vector)
+real student_t_ccdf_log(real[], real, real, row_vector)
+real student_t_ccdf_log(real[], real, vector, real)
+real student_t_ccdf_log(real[], real, vector, vector)
+real student_t_ccdf_log(real[], real, vector, row_vector)
+real student_t_ccdf_log(real[], real, vector, real[])
+real student_t_ccdf_log(real[], real, row_vector, real)
+real student_t_ccdf_log(real[], real, row_vector, vector)
+real student_t_ccdf_log(real[], real, row_vector, row_vector)
+real student_t_ccdf_log(real[], real, row_vector, real[])
+real student_t_ccdf_log(real[], real, real[], vector)
+real student_t_ccdf_log(real[], real, real[], row_vector)
+real student_t_ccdf_log(real[], vector, real, real)
+real student_t_ccdf_log(real[], vector, real, vector)
+real student_t_ccdf_log(real[], vector, real, row_vector)
+real student_t_ccdf_log(real[], vector, real, real[])
+real student_t_ccdf_log(real[], vector, vector, real)
+real student_t_ccdf_log(real[], vector, vector, vector)
+real student_t_ccdf_log(real[], vector, vector, row_vector)
+real student_t_ccdf_log(real[], vector, vector, real[])
+real student_t_ccdf_log(real[], vector, row_vector, real)
+real student_t_ccdf_log(real[], vector, row_vector, vector)
+real student_t_ccdf_log(real[], vector, row_vector, row_vector)
+real student_t_ccdf_log(real[], vector, row_vector, real[])
+real student_t_ccdf_log(real[], vector, real[], real)
+real student_t_ccdf_log(real[], vector, real[], vector)
+real student_t_ccdf_log(real[], vector, real[], row_vector)
+real student_t_ccdf_log(real[], vector, real[], real[])
+real student_t_ccdf_log(real[], row_vector, real, real)
+real student_t_ccdf_log(real[], row_vector, real, vector)
+real student_t_ccdf_log(real[], row_vector, real, row_vector)
+real student_t_ccdf_log(real[], row_vector, real, real[])
+real student_t_ccdf_log(real[], row_vector, vector, real)
+real student_t_ccdf_log(real[], row_vector, vector, vector)
+real student_t_ccdf_log(real[], row_vector, vector, row_vector)
+real student_t_ccdf_log(real[], row_vector, vector, real[])
+real student_t_ccdf_log(real[], row_vector, row_vector, real)
+real student_t_ccdf_log(real[], row_vector, row_vector, vector)
+real student_t_ccdf_log(real[], row_vector, row_vector, row_vector)
+real student_t_ccdf_log(real[], row_vector, row_vector, real[])
+real student_t_ccdf_log(real[], row_vector, real[], real)
+real student_t_ccdf_log(real[], row_vector, real[], vector)
+real student_t_ccdf_log(real[], row_vector, real[], row_vector)
+real student_t_ccdf_log(real[], row_vector, real[], real[])
+real student_t_ccdf_log(real[], real[], real, vector)
+real student_t_ccdf_log(real[], real[], real, row_vector)
+real student_t_ccdf_log(real[], real[], vector, real)
+real student_t_ccdf_log(real[], real[], vector, vector)
+real student_t_ccdf_log(real[], real[], vector, row_vector)
+real student_t_ccdf_log(real[], real[], vector, real[])
+real student_t_ccdf_log(real[], real[], row_vector, real)
+real student_t_ccdf_log(real[], real[], row_vector, vector)
+real student_t_ccdf_log(real[], real[], row_vector, row_vector)
+real student_t_ccdf_log(real[], real[], row_vector, real[])
+real student_t_ccdf_log(real[], real[], real[], vector)
+real student_t_ccdf_log(real[], real[], real[], row_vector)
+real student_t_cdf(real, real, real, vector)
+real student_t_cdf(real, real, real, row_vector)
+real student_t_cdf(real, real, vector, real)
+real student_t_cdf(real, real, vector, vector)
+real student_t_cdf(real, real, vector, row_vector)
+real student_t_cdf(real, real, vector, real[])
+real student_t_cdf(real, real, row_vector, real)
+real student_t_cdf(real, real, row_vector, vector)
+real student_t_cdf(real, real, row_vector, row_vector)
+real student_t_cdf(real, real, row_vector, real[])
+real student_t_cdf(real, real, real[], vector)
+real student_t_cdf(real, real, real[], row_vector)
+real student_t_cdf(real, vector, real, real)
+real student_t_cdf(real, vector, real, vector)
+real student_t_cdf(real, vector, real, row_vector)
+real student_t_cdf(real, vector, real, real[])
+real student_t_cdf(real, vector, vector, real)
+real student_t_cdf(real, vector, vector, vector)
+real student_t_cdf(real, vector, vector, row_vector)
+real student_t_cdf(real, vector, vector, real[])
+real student_t_cdf(real, vector, row_vector, real)
+real student_t_cdf(real, vector, row_vector, vector)
+real student_t_cdf(real, vector, row_vector, row_vector)
+real student_t_cdf(real, vector, row_vector, real[])
+real student_t_cdf(real, vector, real[], real)
+real student_t_cdf(real, vector, real[], vector)
+real student_t_cdf(real, vector, real[], row_vector)
+real student_t_cdf(real, vector, real[], real[])
+real student_t_cdf(real, row_vector, real, real)
+real student_t_cdf(real, row_vector, real, vector)
+real student_t_cdf(real, row_vector, real, row_vector)
+real student_t_cdf(real, row_vector, real, real[])
+real student_t_cdf(real, row_vector, vector, real)
+real student_t_cdf(real, row_vector, vector, vector)
+real student_t_cdf(real, row_vector, vector, row_vector)
+real student_t_cdf(real, row_vector, vector, real[])
+real student_t_cdf(real, row_vector, row_vector, real)
+real student_t_cdf(real, row_vector, row_vector, vector)
+real student_t_cdf(real, row_vector, row_vector, row_vector)
+real student_t_cdf(real, row_vector, row_vector, real[])
+real student_t_cdf(real, row_vector, real[], real)
+real student_t_cdf(real, row_vector, real[], vector)
+real student_t_cdf(real, row_vector, real[], row_vector)
+real student_t_cdf(real, row_vector, real[], real[])
+real student_t_cdf(real, real[], real, vector)
+real student_t_cdf(real, real[], real, row_vector)
+real student_t_cdf(real, real[], vector, real)
+real student_t_cdf(real, real[], vector, vector)
+real student_t_cdf(real, real[], vector, row_vector)
+real student_t_cdf(real, real[], vector, real[])
+real student_t_cdf(real, real[], row_vector, real)
+real student_t_cdf(real, real[], row_vector, vector)
+real student_t_cdf(real, real[], row_vector, row_vector)
+real student_t_cdf(real, real[], row_vector, real[])
+real student_t_cdf(real, real[], real[], vector)
+real student_t_cdf(real, real[], real[], row_vector)
+real student_t_cdf(vector, real, real, real)
+real student_t_cdf(vector, real, real, vector)
+real student_t_cdf(vector, real, real, row_vector)
+real student_t_cdf(vector, real, real, real[])
+real student_t_cdf(vector, real, vector, real)
+real student_t_cdf(vector, real, vector, vector)
+real student_t_cdf(vector, real, vector, row_vector)
+real student_t_cdf(vector, real, vector, real[])
+real student_t_cdf(vector, real, row_vector, real)
+real student_t_cdf(vector, real, row_vector, vector)
+real student_t_cdf(vector, real, row_vector, row_vector)
+real student_t_cdf(vector, real, row_vector, real[])
+real student_t_cdf(vector, real, real[], real)
+real student_t_cdf(vector, real, real[], vector)
+real student_t_cdf(vector, real, real[], row_vector)
+real student_t_cdf(vector, real, real[], real[])
+real student_t_cdf(vector, vector, real, real)
+real student_t_cdf(vector, vector, real, vector)
+real student_t_cdf(vector, vector, real, row_vector)
+real student_t_cdf(vector, vector, real, real[])
+real student_t_cdf(vector, vector, vector, real)
+real student_t_cdf(vector, vector, vector, vector)
+real student_t_cdf(vector, vector, vector, row_vector)
+real student_t_cdf(vector, vector, vector, real[])
+real student_t_cdf(vector, vector, row_vector, real)
+real student_t_cdf(vector, vector, row_vector, vector)
+real student_t_cdf(vector, vector, row_vector, row_vector)
+real student_t_cdf(vector, vector, row_vector, real[])
+real student_t_cdf(vector, vector, real[], real)
+real student_t_cdf(vector, vector, real[], vector)
+real student_t_cdf(vector, vector, real[], row_vector)
+real student_t_cdf(vector, vector, real[], real[])
+real student_t_cdf(vector, row_vector, real, real)
+real student_t_cdf(vector, row_vector, real, vector)
+real student_t_cdf(vector, row_vector, real, row_vector)
+real student_t_cdf(vector, row_vector, real, real[])
+real student_t_cdf(vector, row_vector, vector, real)
+real student_t_cdf(vector, row_vector, vector, vector)
+real student_t_cdf(vector, row_vector, vector, row_vector)
+real student_t_cdf(vector, row_vector, vector, real[])
+real student_t_cdf(vector, row_vector, row_vector, real)
+real student_t_cdf(vector, row_vector, row_vector, vector)
+real student_t_cdf(vector, row_vector, row_vector, row_vector)
+real student_t_cdf(vector, row_vector, row_vector, real[])
+real student_t_cdf(vector, row_vector, real[], real)
+real student_t_cdf(vector, row_vector, real[], vector)
+real student_t_cdf(vector, row_vector, real[], row_vector)
+real student_t_cdf(vector, row_vector, real[], real[])
+real student_t_cdf(vector, real[], real, real)
+real student_t_cdf(vector, real[], real, vector)
+real student_t_cdf(vector, real[], real, row_vector)
+real student_t_cdf(vector, real[], real, real[])
+real student_t_cdf(vector, real[], vector, real)
+real student_t_cdf(vector, real[], vector, vector)
+real student_t_cdf(vector, real[], vector, row_vector)
+real student_t_cdf(vector, real[], vector, real[])
+real student_t_cdf(vector, real[], row_vector, real)
+real student_t_cdf(vector, real[], row_vector, vector)
+real student_t_cdf(vector, real[], row_vector, row_vector)
+real student_t_cdf(vector, real[], row_vector, real[])
+real student_t_cdf(vector, real[], real[], real)
+real student_t_cdf(vector, real[], real[], vector)
+real student_t_cdf(vector, real[], real[], row_vector)
+real student_t_cdf(vector, real[], real[], real[])
+real student_t_cdf(row_vector, real, real, real)
+real student_t_cdf(row_vector, real, real, vector)
+real student_t_cdf(row_vector, real, real, row_vector)
+real student_t_cdf(row_vector, real, real, real[])
+real student_t_cdf(row_vector, real, vector, real)
+real student_t_cdf(row_vector, real, vector, vector)
+real student_t_cdf(row_vector, real, vector, row_vector)
+real student_t_cdf(row_vector, real, vector, real[])
+real student_t_cdf(row_vector, real, row_vector, real)
+real student_t_cdf(row_vector, real, row_vector, vector)
+real student_t_cdf(row_vector, real, row_vector, row_vector)
+real student_t_cdf(row_vector, real, row_vector, real[])
+real student_t_cdf(row_vector, real, real[], real)
+real student_t_cdf(row_vector, real, real[], vector)
+real student_t_cdf(row_vector, real, real[], row_vector)
+real student_t_cdf(row_vector, real, real[], real[])
+real student_t_cdf(row_vector, vector, real, real)
+real student_t_cdf(row_vector, vector, real, vector)
+real student_t_cdf(row_vector, vector, real, row_vector)
+real student_t_cdf(row_vector, vector, real, real[])
+real student_t_cdf(row_vector, vector, vector, real)
+real student_t_cdf(row_vector, vector, vector, vector)
+real student_t_cdf(row_vector, vector, vector, row_vector)
+real student_t_cdf(row_vector, vector, vector, real[])
+real student_t_cdf(row_vector, vector, row_vector, real)
+real student_t_cdf(row_vector, vector, row_vector, vector)
+real student_t_cdf(row_vector, vector, row_vector, row_vector)
+real student_t_cdf(row_vector, vector, row_vector, real[])
+real student_t_cdf(row_vector, vector, real[], real)
+real student_t_cdf(row_vector, vector, real[], vector)
+real student_t_cdf(row_vector, vector, real[], row_vector)
+real student_t_cdf(row_vector, vector, real[], real[])
+real student_t_cdf(row_vector, row_vector, real, real)
+real student_t_cdf(row_vector, row_vector, real, vector)
+real student_t_cdf(row_vector, row_vector, real, row_vector)
+real student_t_cdf(row_vector, row_vector, real, real[])
+real student_t_cdf(row_vector, row_vector, vector, real)
+real student_t_cdf(row_vector, row_vector, vector, vector)
+real student_t_cdf(row_vector, row_vector, vector, row_vector)
+real student_t_cdf(row_vector, row_vector, vector, real[])
+real student_t_cdf(row_vector, row_vector, row_vector, real)
+real student_t_cdf(row_vector, row_vector, row_vector, vector)
+real student_t_cdf(row_vector, row_vector, row_vector, row_vector)
+real student_t_cdf(row_vector, row_vector, row_vector, real[])
+real student_t_cdf(row_vector, row_vector, real[], real)
+real student_t_cdf(row_vector, row_vector, real[], vector)
+real student_t_cdf(row_vector, row_vector, real[], row_vector)
+real student_t_cdf(row_vector, row_vector, real[], real[])
+real student_t_cdf(row_vector, real[], real, real)
+real student_t_cdf(row_vector, real[], real, vector)
+real student_t_cdf(row_vector, real[], real, row_vector)
+real student_t_cdf(row_vector, real[], real, real[])
+real student_t_cdf(row_vector, real[], vector, real)
+real student_t_cdf(row_vector, real[], vector, vector)
+real student_t_cdf(row_vector, real[], vector, row_vector)
+real student_t_cdf(row_vector, real[], vector, real[])
+real student_t_cdf(row_vector, real[], row_vector, real)
+real student_t_cdf(row_vector, real[], row_vector, vector)
+real student_t_cdf(row_vector, real[], row_vector, row_vector)
+real student_t_cdf(row_vector, real[], row_vector, real[])
+real student_t_cdf(row_vector, real[], real[], real)
+real student_t_cdf(row_vector, real[], real[], vector)
+real student_t_cdf(row_vector, real[], real[], row_vector)
+real student_t_cdf(row_vector, real[], real[], real[])
+real student_t_cdf(real[], real, real, vector)
+real student_t_cdf(real[], real, real, row_vector)
+real student_t_cdf(real[], real, vector, real)
+real student_t_cdf(real[], real, vector, vector)
+real student_t_cdf(real[], real, vector, row_vector)
+real student_t_cdf(real[], real, vector, real[])
+real student_t_cdf(real[], real, row_vector, real)
+real student_t_cdf(real[], real, row_vector, vector)
+real student_t_cdf(real[], real, row_vector, row_vector)
+real student_t_cdf(real[], real, row_vector, real[])
+real student_t_cdf(real[], real, real[], vector)
+real student_t_cdf(real[], real, real[], row_vector)
+real student_t_cdf(real[], vector, real, real)
+real student_t_cdf(real[], vector, real, vector)
+real student_t_cdf(real[], vector, real, row_vector)
+real student_t_cdf(real[], vector, real, real[])
+real student_t_cdf(real[], vector, vector, real)
+real student_t_cdf(real[], vector, vector, vector)
+real student_t_cdf(real[], vector, vector, row_vector)
+real student_t_cdf(real[], vector, vector, real[])
+real student_t_cdf(real[], vector, row_vector, real)
+real student_t_cdf(real[], vector, row_vector, vector)
+real student_t_cdf(real[], vector, row_vector, row_vector)
+real student_t_cdf(real[], vector, row_vector, real[])
+real student_t_cdf(real[], vector, real[], real)
+real student_t_cdf(real[], vector, real[], vector)
+real student_t_cdf(real[], vector, real[], row_vector)
+real student_t_cdf(real[], vector, real[], real[])
+real student_t_cdf(real[], row_vector, real, real)
+real student_t_cdf(real[], row_vector, real, vector)
+real student_t_cdf(real[], row_vector, real, row_vector)
+real student_t_cdf(real[], row_vector, real, real[])
+real student_t_cdf(real[], row_vector, vector, real)
+real student_t_cdf(real[], row_vector, vector, vector)
+real student_t_cdf(real[], row_vector, vector, row_vector)
+real student_t_cdf(real[], row_vector, vector, real[])
+real student_t_cdf(real[], row_vector, row_vector, real)
+real student_t_cdf(real[], row_vector, row_vector, vector)
+real student_t_cdf(real[], row_vector, row_vector, row_vector)
+real student_t_cdf(real[], row_vector, row_vector, real[])
+real student_t_cdf(real[], row_vector, real[], real)
+real student_t_cdf(real[], row_vector, real[], vector)
+real student_t_cdf(real[], row_vector, real[], row_vector)
+real student_t_cdf(real[], row_vector, real[], real[])
+real student_t_cdf(real[], real[], real, vector)
+real student_t_cdf(real[], real[], real, row_vector)
+real student_t_cdf(real[], real[], vector, real)
+real student_t_cdf(real[], real[], vector, vector)
+real student_t_cdf(real[], real[], vector, row_vector)
+real student_t_cdf(real[], real[], vector, real[])
+real student_t_cdf(real[], real[], row_vector, real)
+real student_t_cdf(real[], real[], row_vector, vector)
+real student_t_cdf(real[], real[], row_vector, row_vector)
+real student_t_cdf(real[], real[], row_vector, real[])
+real student_t_cdf(real[], real[], real[], vector)
+real student_t_cdf(real[], real[], real[], row_vector)
+real student_t_cdf_log(real, real, real, vector)
+real student_t_cdf_log(real, real, real, row_vector)
+real student_t_cdf_log(real, real, vector, real)
+real student_t_cdf_log(real, real, vector, vector)
+real student_t_cdf_log(real, real, vector, row_vector)
+real student_t_cdf_log(real, real, vector, real[])
+real student_t_cdf_log(real, real, row_vector, real)
+real student_t_cdf_log(real, real, row_vector, vector)
+real student_t_cdf_log(real, real, row_vector, row_vector)
+real student_t_cdf_log(real, real, row_vector, real[])
+real student_t_cdf_log(real, real, real[], vector)
+real student_t_cdf_log(real, real, real[], row_vector)
+real student_t_cdf_log(real, vector, real, real)
+real student_t_cdf_log(real, vector, real, vector)
+real student_t_cdf_log(real, vector, real, row_vector)
+real student_t_cdf_log(real, vector, real, real[])
+real student_t_cdf_log(real, vector, vector, real)
+real student_t_cdf_log(real, vector, vector, vector)
+real student_t_cdf_log(real, vector, vector, row_vector)
+real student_t_cdf_log(real, vector, vector, real[])
+real student_t_cdf_log(real, vector, row_vector, real)
+real student_t_cdf_log(real, vector, row_vector, vector)
+real student_t_cdf_log(real, vector, row_vector, row_vector)
+real student_t_cdf_log(real, vector, row_vector, real[])
+real student_t_cdf_log(real, vector, real[], real)
+real student_t_cdf_log(real, vector, real[], vector)
+real student_t_cdf_log(real, vector, real[], row_vector)
+real student_t_cdf_log(real, vector, real[], real[])
+real student_t_cdf_log(real, row_vector, real, real)
+real student_t_cdf_log(real, row_vector, real, vector)
+real student_t_cdf_log(real, row_vector, real, row_vector)
+real student_t_cdf_log(real, row_vector, real, real[])
+real student_t_cdf_log(real, row_vector, vector, real)
+real student_t_cdf_log(real, row_vector, vector, vector)
+real student_t_cdf_log(real, row_vector, vector, row_vector)
+real student_t_cdf_log(real, row_vector, vector, real[])
+real student_t_cdf_log(real, row_vector, row_vector, real)
+real student_t_cdf_log(real, row_vector, row_vector, vector)
+real student_t_cdf_log(real, row_vector, row_vector, row_vector)
+real student_t_cdf_log(real, row_vector, row_vector, real[])
+real student_t_cdf_log(real, row_vector, real[], real)
+real student_t_cdf_log(real, row_vector, real[], vector)
+real student_t_cdf_log(real, row_vector, real[], row_vector)
+real student_t_cdf_log(real, row_vector, real[], real[])
+real student_t_cdf_log(real, real[], real, vector)
+real student_t_cdf_log(real, real[], real, row_vector)
+real student_t_cdf_log(real, real[], vector, real)
+real student_t_cdf_log(real, real[], vector, vector)
+real student_t_cdf_log(real, real[], vector, row_vector)
+real student_t_cdf_log(real, real[], vector, real[])
+real student_t_cdf_log(real, real[], row_vector, real)
+real student_t_cdf_log(real, real[], row_vector, vector)
+real student_t_cdf_log(real, real[], row_vector, row_vector)
+real student_t_cdf_log(real, real[], row_vector, real[])
+real student_t_cdf_log(real, real[], real[], vector)
+real student_t_cdf_log(real, real[], real[], row_vector)
+real student_t_cdf_log(vector, real, real, real)
+real student_t_cdf_log(vector, real, real, vector)
+real student_t_cdf_log(vector, real, real, row_vector)
+real student_t_cdf_log(vector, real, real, real[])
+real student_t_cdf_log(vector, real, vector, real)
+real student_t_cdf_log(vector, real, vector, vector)
+real student_t_cdf_log(vector, real, vector, row_vector)
+real student_t_cdf_log(vector, real, vector, real[])
+real student_t_cdf_log(vector, real, row_vector, real)
+real student_t_cdf_log(vector, real, row_vector, vector)
+real student_t_cdf_log(vector, real, row_vector, row_vector)
+real student_t_cdf_log(vector, real, row_vector, real[])
+real student_t_cdf_log(vector, real, real[], real)
+real student_t_cdf_log(vector, real, real[], vector)
+real student_t_cdf_log(vector, real, real[], row_vector)
+real student_t_cdf_log(vector, real, real[], real[])
+real student_t_cdf_log(vector, vector, real, real)
+real student_t_cdf_log(vector, vector, real, vector)
+real student_t_cdf_log(vector, vector, real, row_vector)
+real student_t_cdf_log(vector, vector, real, real[])
+real student_t_cdf_log(vector, vector, vector, real)
+real student_t_cdf_log(vector, vector, vector, vector)
+real student_t_cdf_log(vector, vector, vector, row_vector)
+real student_t_cdf_log(vector, vector, vector, real[])
+real student_t_cdf_log(vector, vector, row_vector, real)
+real student_t_cdf_log(vector, vector, row_vector, vector)
+real student_t_cdf_log(vector, vector, row_vector, row_vector)
+real student_t_cdf_log(vector, vector, row_vector, real[])
+real student_t_cdf_log(vector, vector, real[], real)
+real student_t_cdf_log(vector, vector, real[], vector)
+real student_t_cdf_log(vector, vector, real[], row_vector)
+real student_t_cdf_log(vector, vector, real[], real[])
+real student_t_cdf_log(vector, row_vector, real, real)
+real student_t_cdf_log(vector, row_vector, real, vector)
+real student_t_cdf_log(vector, row_vector, real, row_vector)
+real student_t_cdf_log(vector, row_vector, real, real[])
+real student_t_cdf_log(vector, row_vector, vector, real)
+real student_t_cdf_log(vector, row_vector, vector, vector)
+real student_t_cdf_log(vector, row_vector, vector, row_vector)
+real student_t_cdf_log(vector, row_vector, vector, real[])
+real student_t_cdf_log(vector, row_vector, row_vector, real)
+real student_t_cdf_log(vector, row_vector, row_vector, vector)
+real student_t_cdf_log(vector, row_vector, row_vector, row_vector)
+real student_t_cdf_log(vector, row_vector, row_vector, real[])
+real student_t_cdf_log(vector, row_vector, real[], real)
+real student_t_cdf_log(vector, row_vector, real[], vector)
+real student_t_cdf_log(vector, row_vector, real[], row_vector)
+real student_t_cdf_log(vector, row_vector, real[], real[])
+real student_t_cdf_log(vector, real[], real, real)
+real student_t_cdf_log(vector, real[], real, vector)
+real student_t_cdf_log(vector, real[], real, row_vector)
+real student_t_cdf_log(vector, real[], real, real[])
+real student_t_cdf_log(vector, real[], vector, real)
+real student_t_cdf_log(vector, real[], vector, vector)
+real student_t_cdf_log(vector, real[], vector, row_vector)
+real student_t_cdf_log(vector, real[], vector, real[])
+real student_t_cdf_log(vector, real[], row_vector, real)
+real student_t_cdf_log(vector, real[], row_vector, vector)
+real student_t_cdf_log(vector, real[], row_vector, row_vector)
+real student_t_cdf_log(vector, real[], row_vector, real[])
+real student_t_cdf_log(vector, real[], real[], real)
+real student_t_cdf_log(vector, real[], real[], vector)
+real student_t_cdf_log(vector, real[], real[], row_vector)
+real student_t_cdf_log(vector, real[], real[], real[])
+real student_t_cdf_log(row_vector, real, real, real)
+real student_t_cdf_log(row_vector, real, real, vector)
+real student_t_cdf_log(row_vector, real, real, row_vector)
+real student_t_cdf_log(row_vector, real, real, real[])
+real student_t_cdf_log(row_vector, real, vector, real)
+real student_t_cdf_log(row_vector, real, vector, vector)
+real student_t_cdf_log(row_vector, real, vector, row_vector)
+real student_t_cdf_log(row_vector, real, vector, real[])
+real student_t_cdf_log(row_vector, real, row_vector, real)
+real student_t_cdf_log(row_vector, real, row_vector, vector)
+real student_t_cdf_log(row_vector, real, row_vector, row_vector)
+real student_t_cdf_log(row_vector, real, row_vector, real[])
+real student_t_cdf_log(row_vector, real, real[], real)
+real student_t_cdf_log(row_vector, real, real[], vector)
+real student_t_cdf_log(row_vector, real, real[], row_vector)
+real student_t_cdf_log(row_vector, real, real[], real[])
+real student_t_cdf_log(row_vector, vector, real, real)
+real student_t_cdf_log(row_vector, vector, real, vector)
+real student_t_cdf_log(row_vector, vector, real, row_vector)
+real student_t_cdf_log(row_vector, vector, real, real[])
+real student_t_cdf_log(row_vector, vector, vector, real)
+real student_t_cdf_log(row_vector, vector, vector, vector)
+real student_t_cdf_log(row_vector, vector, vector, row_vector)
+real student_t_cdf_log(row_vector, vector, vector, real[])
+real student_t_cdf_log(row_vector, vector, row_vector, real)
+real student_t_cdf_log(row_vector, vector, row_vector, vector)
+real student_t_cdf_log(row_vector, vector, row_vector, row_vector)
+real student_t_cdf_log(row_vector, vector, row_vector, real[])
+real student_t_cdf_log(row_vector, vector, real[], real)
+real student_t_cdf_log(row_vector, vector, real[], vector)
+real student_t_cdf_log(row_vector, vector, real[], row_vector)
+real student_t_cdf_log(row_vector, vector, real[], real[])
+real student_t_cdf_log(row_vector, row_vector, real, real)
+real student_t_cdf_log(row_vector, row_vector, real, vector)
+real student_t_cdf_log(row_vector, row_vector, real, row_vector)
+real student_t_cdf_log(row_vector, row_vector, real, real[])
+real student_t_cdf_log(row_vector, row_vector, vector, real)
+real student_t_cdf_log(row_vector, row_vector, vector, vector)
+real student_t_cdf_log(row_vector, row_vector, vector, row_vector)
+real student_t_cdf_log(row_vector, row_vector, vector, real[])
+real student_t_cdf_log(row_vector, row_vector, row_vector, real)
+real student_t_cdf_log(row_vector, row_vector, row_vector, vector)
+real student_t_cdf_log(row_vector, row_vector, row_vector, row_vector)
+real student_t_cdf_log(row_vector, row_vector, row_vector, real[])
+real student_t_cdf_log(row_vector, row_vector, real[], real)
+real student_t_cdf_log(row_vector, row_vector, real[], vector)
+real student_t_cdf_log(row_vector, row_vector, real[], row_vector)
+real student_t_cdf_log(row_vector, row_vector, real[], real[])
+real student_t_cdf_log(row_vector, real[], real, real)
+real student_t_cdf_log(row_vector, real[], real, vector)
+real student_t_cdf_log(row_vector, real[], real, row_vector)
+real student_t_cdf_log(row_vector, real[], real, real[])
+real student_t_cdf_log(row_vector, real[], vector, real)
+real student_t_cdf_log(row_vector, real[], vector, vector)
+real student_t_cdf_log(row_vector, real[], vector, row_vector)
+real student_t_cdf_log(row_vector, real[], vector, real[])
+real student_t_cdf_log(row_vector, real[], row_vector, real)
+real student_t_cdf_log(row_vector, real[], row_vector, vector)
+real student_t_cdf_log(row_vector, real[], row_vector, row_vector)
+real student_t_cdf_log(row_vector, real[], row_vector, real[])
+real student_t_cdf_log(row_vector, real[], real[], real)
+real student_t_cdf_log(row_vector, real[], real[], vector)
+real student_t_cdf_log(row_vector, real[], real[], row_vector)
+real student_t_cdf_log(row_vector, real[], real[], real[])
+real student_t_cdf_log(real[], real, real, vector)
+real student_t_cdf_log(real[], real, real, row_vector)
+real student_t_cdf_log(real[], real, vector, real)
+real student_t_cdf_log(real[], real, vector, vector)
+real student_t_cdf_log(real[], real, vector, row_vector)
+real student_t_cdf_log(real[], real, vector, real[])
+real student_t_cdf_log(real[], real, row_vector, real)
+real student_t_cdf_log(real[], real, row_vector, vector)
+real student_t_cdf_log(real[], real, row_vector, row_vector)
+real student_t_cdf_log(real[], real, row_vector, real[])
+real student_t_cdf_log(real[], real, real[], vector)
+real student_t_cdf_log(real[], real, real[], row_vector)
+real student_t_cdf_log(real[], vector, real, real)
+real student_t_cdf_log(real[], vector, real, vector)
+real student_t_cdf_log(real[], vector, real, row_vector)
+real student_t_cdf_log(real[], vector, real, real[])
+real student_t_cdf_log(real[], vector, vector, real)
+real student_t_cdf_log(real[], vector, vector, vector)
+real student_t_cdf_log(real[], vector, vector, row_vector)
+real student_t_cdf_log(real[], vector, vector, real[])
+real student_t_cdf_log(real[], vector, row_vector, real)
+real student_t_cdf_log(real[], vector, row_vector, vector)
+real student_t_cdf_log(real[], vector, row_vector, row_vector)
+real student_t_cdf_log(real[], vector, row_vector, real[])
+real student_t_cdf_log(real[], vector, real[], real)
+real student_t_cdf_log(real[], vector, real[], vector)
+real student_t_cdf_log(real[], vector, real[], row_vector)
+real student_t_cdf_log(real[], vector, real[], real[])
+real student_t_cdf_log(real[], row_vector, real, real)
+real student_t_cdf_log(real[], row_vector, real, vector)
+real student_t_cdf_log(real[], row_vector, real, row_vector)
+real student_t_cdf_log(real[], row_vector, real, real[])
+real student_t_cdf_log(real[], row_vector, vector, real)
+real student_t_cdf_log(real[], row_vector, vector, vector)
+real student_t_cdf_log(real[], row_vector, vector, row_vector)
+real student_t_cdf_log(real[], row_vector, vector, real[])
+real student_t_cdf_log(real[], row_vector, row_vector, real)
+real student_t_cdf_log(real[], row_vector, row_vector, vector)
+real student_t_cdf_log(real[], row_vector, row_vector, row_vector)
+real student_t_cdf_log(real[], row_vector, row_vector, real[])
+real student_t_cdf_log(real[], row_vector, real[], real)
+real student_t_cdf_log(real[], row_vector, real[], vector)
+real student_t_cdf_log(real[], row_vector, real[], row_vector)
+real student_t_cdf_log(real[], row_vector, real[], real[])
+real student_t_cdf_log(real[], real[], real, vector)
+real student_t_cdf_log(real[], real[], real, row_vector)
+real student_t_cdf_log(real[], real[], vector, real)
+real student_t_cdf_log(real[], real[], vector, vector)
+real student_t_cdf_log(real[], real[], vector, row_vector)
+real student_t_cdf_log(real[], real[], vector, real[])
+real student_t_cdf_log(real[], real[], row_vector, real)
+real student_t_cdf_log(real[], real[], row_vector, vector)
+real student_t_cdf_log(real[], real[], row_vector, row_vector)
+real student_t_cdf_log(real[], real[], row_vector, real[])
+real student_t_cdf_log(real[], real[], real[], vector)
+real student_t_cdf_log(real[], real[], real[], row_vector)
+real student_t_lccdf(real, real, real, vector)
+real student_t_lccdf(real, real, real, row_vector)
+real student_t_lccdf(real, real, vector, real)
+real student_t_lccdf(real, real, vector, vector)
+real student_t_lccdf(real, real, vector, row_vector)
+real student_t_lccdf(real, real, vector, real[])
+real student_t_lccdf(real, real, row_vector, real)
+real student_t_lccdf(real, real, row_vector, vector)
+real student_t_lccdf(real, real, row_vector, row_vector)
+real student_t_lccdf(real, real, row_vector, real[])
+real student_t_lccdf(real, real, real[], vector)
+real student_t_lccdf(real, real, real[], row_vector)
+real student_t_lccdf(real, vector, real, real)
+real student_t_lccdf(real, vector, real, vector)
+real student_t_lccdf(real, vector, real, row_vector)
+real student_t_lccdf(real, vector, real, real[])
+real student_t_lccdf(real, vector, vector, real)
+real student_t_lccdf(real, vector, vector, vector)
+real student_t_lccdf(real, vector, vector, row_vector)
+real student_t_lccdf(real, vector, vector, real[])
+real student_t_lccdf(real, vector, row_vector, real)
+real student_t_lccdf(real, vector, row_vector, vector)
+real student_t_lccdf(real, vector, row_vector, row_vector)
+real student_t_lccdf(real, vector, row_vector, real[])
+real student_t_lccdf(real, vector, real[], real)
+real student_t_lccdf(real, vector, real[], vector)
+real student_t_lccdf(real, vector, real[], row_vector)
+real student_t_lccdf(real, vector, real[], real[])
+real student_t_lccdf(real, row_vector, real, real)
+real student_t_lccdf(real, row_vector, real, vector)
+real student_t_lccdf(real, row_vector, real, row_vector)
+real student_t_lccdf(real, row_vector, real, real[])
+real student_t_lccdf(real, row_vector, vector, real)
+real student_t_lccdf(real, row_vector, vector, vector)
+real student_t_lccdf(real, row_vector, vector, row_vector)
+real student_t_lccdf(real, row_vector, vector, real[])
+real student_t_lccdf(real, row_vector, row_vector, real)
+real student_t_lccdf(real, row_vector, row_vector, vector)
+real student_t_lccdf(real, row_vector, row_vector, row_vector)
+real student_t_lccdf(real, row_vector, row_vector, real[])
+real student_t_lccdf(real, row_vector, real[], real)
+real student_t_lccdf(real, row_vector, real[], vector)
+real student_t_lccdf(real, row_vector, real[], row_vector)
+real student_t_lccdf(real, row_vector, real[], real[])
+real student_t_lccdf(real, real[], real, vector)
+real student_t_lccdf(real, real[], real, row_vector)
+real student_t_lccdf(real, real[], vector, real)
+real student_t_lccdf(real, real[], vector, vector)
+real student_t_lccdf(real, real[], vector, row_vector)
+real student_t_lccdf(real, real[], vector, real[])
+real student_t_lccdf(real, real[], row_vector, real)
+real student_t_lccdf(real, real[], row_vector, vector)
+real student_t_lccdf(real, real[], row_vector, row_vector)
+real student_t_lccdf(real, real[], row_vector, real[])
+real student_t_lccdf(real, real[], real[], vector)
+real student_t_lccdf(real, real[], real[], row_vector)
+real student_t_lccdf(vector, real, real, real)
+real student_t_lccdf(vector, real, real, vector)
+real student_t_lccdf(vector, real, real, row_vector)
+real student_t_lccdf(vector, real, real, real[])
+real student_t_lccdf(vector, real, vector, real)
+real student_t_lccdf(vector, real, vector, vector)
+real student_t_lccdf(vector, real, vector, row_vector)
+real student_t_lccdf(vector, real, vector, real[])
+real student_t_lccdf(vector, real, row_vector, real)
+real student_t_lccdf(vector, real, row_vector, vector)
+real student_t_lccdf(vector, real, row_vector, row_vector)
+real student_t_lccdf(vector, real, row_vector, real[])
+real student_t_lccdf(vector, real, real[], real)
+real student_t_lccdf(vector, real, real[], vector)
+real student_t_lccdf(vector, real, real[], row_vector)
+real student_t_lccdf(vector, real, real[], real[])
+real student_t_lccdf(vector, vector, real, real)
+real student_t_lccdf(vector, vector, real, vector)
+real student_t_lccdf(vector, vector, real, row_vector)
+real student_t_lccdf(vector, vector, real, real[])
+real student_t_lccdf(vector, vector, vector, real)
+real student_t_lccdf(vector, vector, vector, vector)
+real student_t_lccdf(vector, vector, vector, row_vector)
+real student_t_lccdf(vector, vector, vector, real[])
+real student_t_lccdf(vector, vector, row_vector, real)
+real student_t_lccdf(vector, vector, row_vector, vector)
+real student_t_lccdf(vector, vector, row_vector, row_vector)
+real student_t_lccdf(vector, vector, row_vector, real[])
+real student_t_lccdf(vector, vector, real[], real)
+real student_t_lccdf(vector, vector, real[], vector)
+real student_t_lccdf(vector, vector, real[], row_vector)
+real student_t_lccdf(vector, vector, real[], real[])
+real student_t_lccdf(vector, row_vector, real, real)
+real student_t_lccdf(vector, row_vector, real, vector)
+real student_t_lccdf(vector, row_vector, real, row_vector)
+real student_t_lccdf(vector, row_vector, real, real[])
+real student_t_lccdf(vector, row_vector, vector, real)
+real student_t_lccdf(vector, row_vector, vector, vector)
+real student_t_lccdf(vector, row_vector, vector, row_vector)
+real student_t_lccdf(vector, row_vector, vector, real[])
+real student_t_lccdf(vector, row_vector, row_vector, real)
+real student_t_lccdf(vector, row_vector, row_vector, vector)
+real student_t_lccdf(vector, row_vector, row_vector, row_vector)
+real student_t_lccdf(vector, row_vector, row_vector, real[])
+real student_t_lccdf(vector, row_vector, real[], real)
+real student_t_lccdf(vector, row_vector, real[], vector)
+real student_t_lccdf(vector, row_vector, real[], row_vector)
+real student_t_lccdf(vector, row_vector, real[], real[])
+real student_t_lccdf(vector, real[], real, real)
+real student_t_lccdf(vector, real[], real, vector)
+real student_t_lccdf(vector, real[], real, row_vector)
+real student_t_lccdf(vector, real[], real, real[])
+real student_t_lccdf(vector, real[], vector, real)
+real student_t_lccdf(vector, real[], vector, vector)
+real student_t_lccdf(vector, real[], vector, row_vector)
+real student_t_lccdf(vector, real[], vector, real[])
+real student_t_lccdf(vector, real[], row_vector, real)
+real student_t_lccdf(vector, real[], row_vector, vector)
+real student_t_lccdf(vector, real[], row_vector, row_vector)
+real student_t_lccdf(vector, real[], row_vector, real[])
+real student_t_lccdf(vector, real[], real[], real)
+real student_t_lccdf(vector, real[], real[], vector)
+real student_t_lccdf(vector, real[], real[], row_vector)
+real student_t_lccdf(vector, real[], real[], real[])
+real student_t_lccdf(row_vector, real, real, real)
+real student_t_lccdf(row_vector, real, real, vector)
+real student_t_lccdf(row_vector, real, real, row_vector)
+real student_t_lccdf(row_vector, real, real, real[])
+real student_t_lccdf(row_vector, real, vector, real)
+real student_t_lccdf(row_vector, real, vector, vector)
+real student_t_lccdf(row_vector, real, vector, row_vector)
+real student_t_lccdf(row_vector, real, vector, real[])
+real student_t_lccdf(row_vector, real, row_vector, real)
+real student_t_lccdf(row_vector, real, row_vector, vector)
+real student_t_lccdf(row_vector, real, row_vector, row_vector)
+real student_t_lccdf(row_vector, real, row_vector, real[])
+real student_t_lccdf(row_vector, real, real[], real)
+real student_t_lccdf(row_vector, real, real[], vector)
+real student_t_lccdf(row_vector, real, real[], row_vector)
+real student_t_lccdf(row_vector, real, real[], real[])
+real student_t_lccdf(row_vector, vector, real, real)
+real student_t_lccdf(row_vector, vector, real, vector)
+real student_t_lccdf(row_vector, vector, real, row_vector)
+real student_t_lccdf(row_vector, vector, real, real[])
+real student_t_lccdf(row_vector, vector, vector, real)
+real student_t_lccdf(row_vector, vector, vector, vector)
+real student_t_lccdf(row_vector, vector, vector, row_vector)
+real student_t_lccdf(row_vector, vector, vector, real[])
+real student_t_lccdf(row_vector, vector, row_vector, real)
+real student_t_lccdf(row_vector, vector, row_vector, vector)
+real student_t_lccdf(row_vector, vector, row_vector, row_vector)
+real student_t_lccdf(row_vector, vector, row_vector, real[])
+real student_t_lccdf(row_vector, vector, real[], real)
+real student_t_lccdf(row_vector, vector, real[], vector)
+real student_t_lccdf(row_vector, vector, real[], row_vector)
+real student_t_lccdf(row_vector, vector, real[], real[])
+real student_t_lccdf(row_vector, row_vector, real, real)
+real student_t_lccdf(row_vector, row_vector, real, vector)
+real student_t_lccdf(row_vector, row_vector, real, row_vector)
+real student_t_lccdf(row_vector, row_vector, real, real[])
+real student_t_lccdf(row_vector, row_vector, vector, real)
+real student_t_lccdf(row_vector, row_vector, vector, vector)
+real student_t_lccdf(row_vector, row_vector, vector, row_vector)
+real student_t_lccdf(row_vector, row_vector, vector, real[])
+real student_t_lccdf(row_vector, row_vector, row_vector, real)
+real student_t_lccdf(row_vector, row_vector, row_vector, vector)
+real student_t_lccdf(row_vector, row_vector, row_vector, row_vector)
+real student_t_lccdf(row_vector, row_vector, row_vector, real[])
+real student_t_lccdf(row_vector, row_vector, real[], real)
+real student_t_lccdf(row_vector, row_vector, real[], vector)
+real student_t_lccdf(row_vector, row_vector, real[], row_vector)
+real student_t_lccdf(row_vector, row_vector, real[], real[])
+real student_t_lccdf(row_vector, real[], real, real)
+real student_t_lccdf(row_vector, real[], real, vector)
+real student_t_lccdf(row_vector, real[], real, row_vector)
+real student_t_lccdf(row_vector, real[], real, real[])
+real student_t_lccdf(row_vector, real[], vector, real)
+real student_t_lccdf(row_vector, real[], vector, vector)
+real student_t_lccdf(row_vector, real[], vector, row_vector)
+real student_t_lccdf(row_vector, real[], vector, real[])
+real student_t_lccdf(row_vector, real[], row_vector, real)
+real student_t_lccdf(row_vector, real[], row_vector, vector)
+real student_t_lccdf(row_vector, real[], row_vector, row_vector)
+real student_t_lccdf(row_vector, real[], row_vector, real[])
+real student_t_lccdf(row_vector, real[], real[], real)
+real student_t_lccdf(row_vector, real[], real[], vector)
+real student_t_lccdf(row_vector, real[], real[], row_vector)
+real student_t_lccdf(row_vector, real[], real[], real[])
+real student_t_lccdf(real[], real, real, vector)
+real student_t_lccdf(real[], real, real, row_vector)
+real student_t_lccdf(real[], real, vector, real)
+real student_t_lccdf(real[], real, vector, vector)
+real student_t_lccdf(real[], real, vector, row_vector)
+real student_t_lccdf(real[], real, vector, real[])
+real student_t_lccdf(real[], real, row_vector, real)
+real student_t_lccdf(real[], real, row_vector, vector)
+real student_t_lccdf(real[], real, row_vector, row_vector)
+real student_t_lccdf(real[], real, row_vector, real[])
+real student_t_lccdf(real[], real, real[], vector)
+real student_t_lccdf(real[], real, real[], row_vector)
+real student_t_lccdf(real[], vector, real, real)
+real student_t_lccdf(real[], vector, real, vector)
+real student_t_lccdf(real[], vector, real, row_vector)
+real student_t_lccdf(real[], vector, real, real[])
+real student_t_lccdf(real[], vector, vector, real)
+real student_t_lccdf(real[], vector, vector, vector)
+real student_t_lccdf(real[], vector, vector, row_vector)
+real student_t_lccdf(real[], vector, vector, real[])
+real student_t_lccdf(real[], vector, row_vector, real)
+real student_t_lccdf(real[], vector, row_vector, vector)
+real student_t_lccdf(real[], vector, row_vector, row_vector)
+real student_t_lccdf(real[], vector, row_vector, real[])
+real student_t_lccdf(real[], vector, real[], real)
+real student_t_lccdf(real[], vector, real[], vector)
+real student_t_lccdf(real[], vector, real[], row_vector)
+real student_t_lccdf(real[], vector, real[], real[])
+real student_t_lccdf(real[], row_vector, real, real)
+real student_t_lccdf(real[], row_vector, real, vector)
+real student_t_lccdf(real[], row_vector, real, row_vector)
+real student_t_lccdf(real[], row_vector, real, real[])
+real student_t_lccdf(real[], row_vector, vector, real)
+real student_t_lccdf(real[], row_vector, vector, vector)
+real student_t_lccdf(real[], row_vector, vector, row_vector)
+real student_t_lccdf(real[], row_vector, vector, real[])
+real student_t_lccdf(real[], row_vector, row_vector, real)
+real student_t_lccdf(real[], row_vector, row_vector, vector)
+real student_t_lccdf(real[], row_vector, row_vector, row_vector)
+real student_t_lccdf(real[], row_vector, row_vector, real[])
+real student_t_lccdf(real[], row_vector, real[], real)
+real student_t_lccdf(real[], row_vector, real[], vector)
+real student_t_lccdf(real[], row_vector, real[], row_vector)
+real student_t_lccdf(real[], row_vector, real[], real[])
+real student_t_lccdf(real[], real[], real, vector)
+real student_t_lccdf(real[], real[], real, row_vector)
+real student_t_lccdf(real[], real[], vector, real)
+real student_t_lccdf(real[], real[], vector, vector)
+real student_t_lccdf(real[], real[], vector, row_vector)
+real student_t_lccdf(real[], real[], vector, real[])
+real student_t_lccdf(real[], real[], row_vector, real)
+real student_t_lccdf(real[], real[], row_vector, vector)
+real student_t_lccdf(real[], real[], row_vector, row_vector)
+real student_t_lccdf(real[], real[], row_vector, real[])
+real student_t_lccdf(real[], real[], real[], vector)
+real student_t_lccdf(real[], real[], real[], row_vector)
+real student_t_lcdf(real, real, real, vector)
+real student_t_lcdf(real, real, real, row_vector)
+real student_t_lcdf(real, real, vector, real)
+real student_t_lcdf(real, real, vector, vector)
+real student_t_lcdf(real, real, vector, row_vector)
+real student_t_lcdf(real, real, vector, real[])
+real student_t_lcdf(real, real, row_vector, real)
+real student_t_lcdf(real, real, row_vector, vector)
+real student_t_lcdf(real, real, row_vector, row_vector)
+real student_t_lcdf(real, real, row_vector, real[])
+real student_t_lcdf(real, real, real[], vector)
+real student_t_lcdf(real, real, real[], row_vector)
+real student_t_lcdf(real, vector, real, real)
+real student_t_lcdf(real, vector, real, vector)
+real student_t_lcdf(real, vector, real, row_vector)
+real student_t_lcdf(real, vector, real, real[])
+real student_t_lcdf(real, vector, vector, real)
+real student_t_lcdf(real, vector, vector, vector)
+real student_t_lcdf(real, vector, vector, row_vector)
+real student_t_lcdf(real, vector, vector, real[])
+real student_t_lcdf(real, vector, row_vector, real)
+real student_t_lcdf(real, vector, row_vector, vector)
+real student_t_lcdf(real, vector, row_vector, row_vector)
+real student_t_lcdf(real, vector, row_vector, real[])
+real student_t_lcdf(real, vector, real[], real)
+real student_t_lcdf(real, vector, real[], vector)
+real student_t_lcdf(real, vector, real[], row_vector)
+real student_t_lcdf(real, vector, real[], real[])
+real student_t_lcdf(real, row_vector, real, real)
+real student_t_lcdf(real, row_vector, real, vector)
+real student_t_lcdf(real, row_vector, real, row_vector)
+real student_t_lcdf(real, row_vector, real, real[])
+real student_t_lcdf(real, row_vector, vector, real)
+real student_t_lcdf(real, row_vector, vector, vector)
+real student_t_lcdf(real, row_vector, vector, row_vector)
+real student_t_lcdf(real, row_vector, vector, real[])
+real student_t_lcdf(real, row_vector, row_vector, real)
+real student_t_lcdf(real, row_vector, row_vector, vector)
+real student_t_lcdf(real, row_vector, row_vector, row_vector)
+real student_t_lcdf(real, row_vector, row_vector, real[])
+real student_t_lcdf(real, row_vector, real[], real)
+real student_t_lcdf(real, row_vector, real[], vector)
+real student_t_lcdf(real, row_vector, real[], row_vector)
+real student_t_lcdf(real, row_vector, real[], real[])
+real student_t_lcdf(real, real[], real, vector)
+real student_t_lcdf(real, real[], real, row_vector)
+real student_t_lcdf(real, real[], vector, real)
+real student_t_lcdf(real, real[], vector, vector)
+real student_t_lcdf(real, real[], vector, row_vector)
+real student_t_lcdf(real, real[], vector, real[])
+real student_t_lcdf(real, real[], row_vector, real)
+real student_t_lcdf(real, real[], row_vector, vector)
+real student_t_lcdf(real, real[], row_vector, row_vector)
+real student_t_lcdf(real, real[], row_vector, real[])
+real student_t_lcdf(real, real[], real[], vector)
+real student_t_lcdf(real, real[], real[], row_vector)
+real student_t_lcdf(vector, real, real, real)
+real student_t_lcdf(vector, real, real, vector)
+real student_t_lcdf(vector, real, real, row_vector)
+real student_t_lcdf(vector, real, real, real[])
+real student_t_lcdf(vector, real, vector, real)
+real student_t_lcdf(vector, real, vector, vector)
+real student_t_lcdf(vector, real, vector, row_vector)
+real student_t_lcdf(vector, real, vector, real[])
+real student_t_lcdf(vector, real, row_vector, real)
+real student_t_lcdf(vector, real, row_vector, vector)
+real student_t_lcdf(vector, real, row_vector, row_vector)
+real student_t_lcdf(vector, real, row_vector, real[])
+real student_t_lcdf(vector, real, real[], real)
+real student_t_lcdf(vector, real, real[], vector)
+real student_t_lcdf(vector, real, real[], row_vector)
+real student_t_lcdf(vector, real, real[], real[])
+real student_t_lcdf(vector, vector, real, real)
+real student_t_lcdf(vector, vector, real, vector)
+real student_t_lcdf(vector, vector, real, row_vector)
+real student_t_lcdf(vector, vector, real, real[])
+real student_t_lcdf(vector, vector, vector, real)
+real student_t_lcdf(vector, vector, vector, vector)
+real student_t_lcdf(vector, vector, vector, row_vector)
+real student_t_lcdf(vector, vector, vector, real[])
+real student_t_lcdf(vector, vector, row_vector, real)
+real student_t_lcdf(vector, vector, row_vector, vector)
+real student_t_lcdf(vector, vector, row_vector, row_vector)
+real student_t_lcdf(vector, vector, row_vector, real[])
+real student_t_lcdf(vector, vector, real[], real)
+real student_t_lcdf(vector, vector, real[], vector)
+real student_t_lcdf(vector, vector, real[], row_vector)
+real student_t_lcdf(vector, vector, real[], real[])
+real student_t_lcdf(vector, row_vector, real, real)
+real student_t_lcdf(vector, row_vector, real, vector)
+real student_t_lcdf(vector, row_vector, real, row_vector)
+real student_t_lcdf(vector, row_vector, real, real[])
+real student_t_lcdf(vector, row_vector, vector, real)
+real student_t_lcdf(vector, row_vector, vector, vector)
+real student_t_lcdf(vector, row_vector, vector, row_vector)
+real student_t_lcdf(vector, row_vector, vector, real[])
+real student_t_lcdf(vector, row_vector, row_vector, real)
+real student_t_lcdf(vector, row_vector, row_vector, vector)
+real student_t_lcdf(vector, row_vector, row_vector, row_vector)
+real student_t_lcdf(vector, row_vector, row_vector, real[])
+real student_t_lcdf(vector, row_vector, real[], real)
+real student_t_lcdf(vector, row_vector, real[], vector)
+real student_t_lcdf(vector, row_vector, real[], row_vector)
+real student_t_lcdf(vector, row_vector, real[], real[])
+real student_t_lcdf(vector, real[], real, real)
+real student_t_lcdf(vector, real[], real, vector)
+real student_t_lcdf(vector, real[], real, row_vector)
+real student_t_lcdf(vector, real[], real, real[])
+real student_t_lcdf(vector, real[], vector, real)
+real student_t_lcdf(vector, real[], vector, vector)
+real student_t_lcdf(vector, real[], vector, row_vector)
+real student_t_lcdf(vector, real[], vector, real[])
+real student_t_lcdf(vector, real[], row_vector, real)
+real student_t_lcdf(vector, real[], row_vector, vector)
+real student_t_lcdf(vector, real[], row_vector, row_vector)
+real student_t_lcdf(vector, real[], row_vector, real[])
+real student_t_lcdf(vector, real[], real[], real)
+real student_t_lcdf(vector, real[], real[], vector)
+real student_t_lcdf(vector, real[], real[], row_vector)
+real student_t_lcdf(vector, real[], real[], real[])
+real student_t_lcdf(row_vector, real, real, real)
+real student_t_lcdf(row_vector, real, real, vector)
+real student_t_lcdf(row_vector, real, real, row_vector)
+real student_t_lcdf(row_vector, real, real, real[])
+real student_t_lcdf(row_vector, real, vector, real)
+real student_t_lcdf(row_vector, real, vector, vector)
+real student_t_lcdf(row_vector, real, vector, row_vector)
+real student_t_lcdf(row_vector, real, vector, real[])
+real student_t_lcdf(row_vector, real, row_vector, real)
+real student_t_lcdf(row_vector, real, row_vector, vector)
+real student_t_lcdf(row_vector, real, row_vector, row_vector)
+real student_t_lcdf(row_vector, real, row_vector, real[])
+real student_t_lcdf(row_vector, real, real[], real)
+real student_t_lcdf(row_vector, real, real[], vector)
+real student_t_lcdf(row_vector, real, real[], row_vector)
+real student_t_lcdf(row_vector, real, real[], real[])
+real student_t_lcdf(row_vector, vector, real, real)
+real student_t_lcdf(row_vector, vector, real, vector)
+real student_t_lcdf(row_vector, vector, real, row_vector)
+real student_t_lcdf(row_vector, vector, real, real[])
+real student_t_lcdf(row_vector, vector, vector, real)
+real student_t_lcdf(row_vector, vector, vector, vector)
+real student_t_lcdf(row_vector, vector, vector, row_vector)
+real student_t_lcdf(row_vector, vector, vector, real[])
+real student_t_lcdf(row_vector, vector, row_vector, real)
+real student_t_lcdf(row_vector, vector, row_vector, vector)
+real student_t_lcdf(row_vector, vector, row_vector, row_vector)
+real student_t_lcdf(row_vector, vector, row_vector, real[])
+real student_t_lcdf(row_vector, vector, real[], real)
+real student_t_lcdf(row_vector, vector, real[], vector)
+real student_t_lcdf(row_vector, vector, real[], row_vector)
+real student_t_lcdf(row_vector, vector, real[], real[])
+real student_t_lcdf(row_vector, row_vector, real, real)
+real student_t_lcdf(row_vector, row_vector, real, vector)
+real student_t_lcdf(row_vector, row_vector, real, row_vector)
+real student_t_lcdf(row_vector, row_vector, real, real[])
+real student_t_lcdf(row_vector, row_vector, vector, real)
+real student_t_lcdf(row_vector, row_vector, vector, vector)
+real student_t_lcdf(row_vector, row_vector, vector, row_vector)
+real student_t_lcdf(row_vector, row_vector, vector, real[])
+real student_t_lcdf(row_vector, row_vector, row_vector, real)
+real student_t_lcdf(row_vector, row_vector, row_vector, vector)
+real student_t_lcdf(row_vector, row_vector, row_vector, row_vector)
+real student_t_lcdf(row_vector, row_vector, row_vector, real[])
+real student_t_lcdf(row_vector, row_vector, real[], real)
+real student_t_lcdf(row_vector, row_vector, real[], vector)
+real student_t_lcdf(row_vector, row_vector, real[], row_vector)
+real student_t_lcdf(row_vector, row_vector, real[], real[])
+real student_t_lcdf(row_vector, real[], real, real)
+real student_t_lcdf(row_vector, real[], real, vector)
+real student_t_lcdf(row_vector, real[], real, row_vector)
+real student_t_lcdf(row_vector, real[], real, real[])
+real student_t_lcdf(row_vector, real[], vector, real)
+real student_t_lcdf(row_vector, real[], vector, vector)
+real student_t_lcdf(row_vector, real[], vector, row_vector)
+real student_t_lcdf(row_vector, real[], vector, real[])
+real student_t_lcdf(row_vector, real[], row_vector, real)
+real student_t_lcdf(row_vector, real[], row_vector, vector)
+real student_t_lcdf(row_vector, real[], row_vector, row_vector)
+real student_t_lcdf(row_vector, real[], row_vector, real[])
+real student_t_lcdf(row_vector, real[], real[], real)
+real student_t_lcdf(row_vector, real[], real[], vector)
+real student_t_lcdf(row_vector, real[], real[], row_vector)
+real student_t_lcdf(row_vector, real[], real[], real[])
+real student_t_lcdf(real[], real, real, vector)
+real student_t_lcdf(real[], real, real, row_vector)
+real student_t_lcdf(real[], real, vector, real)
+real student_t_lcdf(real[], real, vector, vector)
+real student_t_lcdf(real[], real, vector, row_vector)
+real student_t_lcdf(real[], real, vector, real[])
+real student_t_lcdf(real[], real, row_vector, real)
+real student_t_lcdf(real[], real, row_vector, vector)
+real student_t_lcdf(real[], real, row_vector, row_vector)
+real student_t_lcdf(real[], real, row_vector, real[])
+real student_t_lcdf(real[], real, real[], vector)
+real student_t_lcdf(real[], real, real[], row_vector)
+real student_t_lcdf(real[], vector, real, real)
+real student_t_lcdf(real[], vector, real, vector)
+real student_t_lcdf(real[], vector, real, row_vector)
+real student_t_lcdf(real[], vector, real, real[])
+real student_t_lcdf(real[], vector, vector, real)
+real student_t_lcdf(real[], vector, vector, vector)
+real student_t_lcdf(real[], vector, vector, row_vector)
+real student_t_lcdf(real[], vector, vector, real[])
+real student_t_lcdf(real[], vector, row_vector, real)
+real student_t_lcdf(real[], vector, row_vector, vector)
+real student_t_lcdf(real[], vector, row_vector, row_vector)
+real student_t_lcdf(real[], vector, row_vector, real[])
+real student_t_lcdf(real[], vector, real[], real)
+real student_t_lcdf(real[], vector, real[], vector)
+real student_t_lcdf(real[], vector, real[], row_vector)
+real student_t_lcdf(real[], vector, real[], real[])
+real student_t_lcdf(real[], row_vector, real, real)
+real student_t_lcdf(real[], row_vector, real, vector)
+real student_t_lcdf(real[], row_vector, real, row_vector)
+real student_t_lcdf(real[], row_vector, real, real[])
+real student_t_lcdf(real[], row_vector, vector, real)
+real student_t_lcdf(real[], row_vector, vector, vector)
+real student_t_lcdf(real[], row_vector, vector, row_vector)
+real student_t_lcdf(real[], row_vector, vector, real[])
+real student_t_lcdf(real[], row_vector, row_vector, real)
+real student_t_lcdf(real[], row_vector, row_vector, vector)
+real student_t_lcdf(real[], row_vector, row_vector, row_vector)
+real student_t_lcdf(real[], row_vector, row_vector, real[])
+real student_t_lcdf(real[], row_vector, real[], real)
+real student_t_lcdf(real[], row_vector, real[], vector)
+real student_t_lcdf(real[], row_vector, real[], row_vector)
+real student_t_lcdf(real[], row_vector, real[], real[])
+real student_t_lcdf(real[], real[], real, vector)
+real student_t_lcdf(real[], real[], real, row_vector)
+real student_t_lcdf(real[], real[], vector, real)
+real student_t_lcdf(real[], real[], vector, vector)
+real student_t_lcdf(real[], real[], vector, row_vector)
+real student_t_lcdf(real[], real[], vector, real[])
+real student_t_lcdf(real[], real[], row_vector, real)
+real student_t_lcdf(real[], real[], row_vector, vector)
+real student_t_lcdf(real[], real[], row_vector, row_vector)
+real student_t_lcdf(real[], real[], row_vector, real[])
+real student_t_lcdf(real[], real[], real[], vector)
+real student_t_lcdf(real[], real[], real[], row_vector)
+real student_t_log(real, real, real, vector)
+real student_t_log(real, real, real, row_vector)
+real student_t_log(real, real, vector, real)
+real student_t_log(real, real, vector, vector)
+real student_t_log(real, real, vector, row_vector)
+real student_t_log(real, real, vector, real[])
+real student_t_log(real, real, row_vector, real)
+real student_t_log(real, real, row_vector, vector)
+real student_t_log(real, real, row_vector, row_vector)
+real student_t_log(real, real, row_vector, real[])
+real student_t_log(real, real, real[], vector)
+real student_t_log(real, real, real[], row_vector)
+real student_t_log(real, vector, real, real)
+real student_t_log(real, vector, real, vector)
+real student_t_log(real, vector, real, row_vector)
+real student_t_log(real, vector, real, real[])
+real student_t_log(real, vector, vector, real)
+real student_t_log(real, vector, vector, vector)
+real student_t_log(real, vector, vector, row_vector)
+real student_t_log(real, vector, vector, real[])
+real student_t_log(real, vector, row_vector, real)
+real student_t_log(real, vector, row_vector, vector)
+real student_t_log(real, vector, row_vector, row_vector)
+real student_t_log(real, vector, row_vector, real[])
+real student_t_log(real, vector, real[], real)
+real student_t_log(real, vector, real[], vector)
+real student_t_log(real, vector, real[], row_vector)
+real student_t_log(real, vector, real[], real[])
+real student_t_log(real, row_vector, real, real)
+real student_t_log(real, row_vector, real, vector)
+real student_t_log(real, row_vector, real, row_vector)
+real student_t_log(real, row_vector, real, real[])
+real student_t_log(real, row_vector, vector, real)
+real student_t_log(real, row_vector, vector, vector)
+real student_t_log(real, row_vector, vector, row_vector)
+real student_t_log(real, row_vector, vector, real[])
+real student_t_log(real, row_vector, row_vector, real)
+real student_t_log(real, row_vector, row_vector, vector)
+real student_t_log(real, row_vector, row_vector, row_vector)
+real student_t_log(real, row_vector, row_vector, real[])
+real student_t_log(real, row_vector, real[], real)
+real student_t_log(real, row_vector, real[], vector)
+real student_t_log(real, row_vector, real[], row_vector)
+real student_t_log(real, row_vector, real[], real[])
+real student_t_log(real, real[], real, vector)
+real student_t_log(real, real[], real, row_vector)
+real student_t_log(real, real[], vector, real)
+real student_t_log(real, real[], vector, vector)
+real student_t_log(real, real[], vector, row_vector)
+real student_t_log(real, real[], vector, real[])
+real student_t_log(real, real[], row_vector, real)
+real student_t_log(real, real[], row_vector, vector)
+real student_t_log(real, real[], row_vector, row_vector)
+real student_t_log(real, real[], row_vector, real[])
+real student_t_log(real, real[], real[], vector)
+real student_t_log(real, real[], real[], row_vector)
+real student_t_log(vector, real, real, real)
+real student_t_log(vector, real, real, vector)
+real student_t_log(vector, real, real, row_vector)
+real student_t_log(vector, real, real, real[])
+real student_t_log(vector, real, vector, real)
+real student_t_log(vector, real, vector, vector)
+real student_t_log(vector, real, vector, row_vector)
+real student_t_log(vector, real, vector, real[])
+real student_t_log(vector, real, row_vector, real)
+real student_t_log(vector, real, row_vector, vector)
+real student_t_log(vector, real, row_vector, row_vector)
+real student_t_log(vector, real, row_vector, real[])
+real student_t_log(vector, real, real[], real)
+real student_t_log(vector, real, real[], vector)
+real student_t_log(vector, real, real[], row_vector)
+real student_t_log(vector, real, real[], real[])
+real student_t_log(vector, vector, real, real)
+real student_t_log(vector, vector, real, vector)
+real student_t_log(vector, vector, real, row_vector)
+real student_t_log(vector, vector, real, real[])
+real student_t_log(vector, vector, vector, real)
+real student_t_log(vector, vector, vector, vector)
+real student_t_log(vector, vector, vector, row_vector)
+real student_t_log(vector, vector, vector, real[])
+real student_t_log(vector, vector, row_vector, real)
+real student_t_log(vector, vector, row_vector, vector)
+real student_t_log(vector, vector, row_vector, row_vector)
+real student_t_log(vector, vector, row_vector, real[])
+real student_t_log(vector, vector, real[], real)
+real student_t_log(vector, vector, real[], vector)
+real student_t_log(vector, vector, real[], row_vector)
+real student_t_log(vector, vector, real[], real[])
+real student_t_log(vector, row_vector, real, real)
+real student_t_log(vector, row_vector, real, vector)
+real student_t_log(vector, row_vector, real, row_vector)
+real student_t_log(vector, row_vector, real, real[])
+real student_t_log(vector, row_vector, vector, real)
+real student_t_log(vector, row_vector, vector, vector)
+real student_t_log(vector, row_vector, vector, row_vector)
+real student_t_log(vector, row_vector, vector, real[])
+real student_t_log(vector, row_vector, row_vector, real)
+real student_t_log(vector, row_vector, row_vector, vector)
+real student_t_log(vector, row_vector, row_vector, row_vector)
+real student_t_log(vector, row_vector, row_vector, real[])
+real student_t_log(vector, row_vector, real[], real)
+real student_t_log(vector, row_vector, real[], vector)
+real student_t_log(vector, row_vector, real[], row_vector)
+real student_t_log(vector, row_vector, real[], real[])
+real student_t_log(vector, real[], real, real)
+real student_t_log(vector, real[], real, vector)
+real student_t_log(vector, real[], real, row_vector)
+real student_t_log(vector, real[], real, real[])
+real student_t_log(vector, real[], vector, real)
+real student_t_log(vector, real[], vector, vector)
+real student_t_log(vector, real[], vector, row_vector)
+real student_t_log(vector, real[], vector, real[])
+real student_t_log(vector, real[], row_vector, real)
+real student_t_log(vector, real[], row_vector, vector)
+real student_t_log(vector, real[], row_vector, row_vector)
+real student_t_log(vector, real[], row_vector, real[])
+real student_t_log(vector, real[], real[], real)
+real student_t_log(vector, real[], real[], vector)
+real student_t_log(vector, real[], real[], row_vector)
+real student_t_log(vector, real[], real[], real[])
+real student_t_log(row_vector, real, real, real)
+real student_t_log(row_vector, real, real, vector)
+real student_t_log(row_vector, real, real, row_vector)
+real student_t_log(row_vector, real, real, real[])
+real student_t_log(row_vector, real, vector, real)
+real student_t_log(row_vector, real, vector, vector)
+real student_t_log(row_vector, real, vector, row_vector)
+real student_t_log(row_vector, real, vector, real[])
+real student_t_log(row_vector, real, row_vector, real)
+real student_t_log(row_vector, real, row_vector, vector)
+real student_t_log(row_vector, real, row_vector, row_vector)
+real student_t_log(row_vector, real, row_vector, real[])
+real student_t_log(row_vector, real, real[], real)
+real student_t_log(row_vector, real, real[], vector)
+real student_t_log(row_vector, real, real[], row_vector)
+real student_t_log(row_vector, real, real[], real[])
+real student_t_log(row_vector, vector, real, real)
+real student_t_log(row_vector, vector, real, vector)
+real student_t_log(row_vector, vector, real, row_vector)
+real student_t_log(row_vector, vector, real, real[])
+real student_t_log(row_vector, vector, vector, real)
+real student_t_log(row_vector, vector, vector, vector)
+real student_t_log(row_vector, vector, vector, row_vector)
+real student_t_log(row_vector, vector, vector, real[])
+real student_t_log(row_vector, vector, row_vector, real)
+real student_t_log(row_vector, vector, row_vector, vector)
+real student_t_log(row_vector, vector, row_vector, row_vector)
+real student_t_log(row_vector, vector, row_vector, real[])
+real student_t_log(row_vector, vector, real[], real)
+real student_t_log(row_vector, vector, real[], vector)
+real student_t_log(row_vector, vector, real[], row_vector)
+real student_t_log(row_vector, vector, real[], real[])
+real student_t_log(row_vector, row_vector, real, real)
+real student_t_log(row_vector, row_vector, real, vector)
+real student_t_log(row_vector, row_vector, real, row_vector)
+real student_t_log(row_vector, row_vector, real, real[])
+real student_t_log(row_vector, row_vector, vector, real)
+real student_t_log(row_vector, row_vector, vector, vector)
+real student_t_log(row_vector, row_vector, vector, row_vector)
+real student_t_log(row_vector, row_vector, vector, real[])
+real student_t_log(row_vector, row_vector, row_vector, real)
+real student_t_log(row_vector, row_vector, row_vector, vector)
+real student_t_log(row_vector, row_vector, row_vector, row_vector)
+real student_t_log(row_vector, row_vector, row_vector, real[])
+real student_t_log(row_vector, row_vector, real[], real)
+real student_t_log(row_vector, row_vector, real[], vector)
+real student_t_log(row_vector, row_vector, real[], row_vector)
+real student_t_log(row_vector, row_vector, real[], real[])
+real student_t_log(row_vector, real[], real, real)
+real student_t_log(row_vector, real[], real, vector)
+real student_t_log(row_vector, real[], real, row_vector)
+real student_t_log(row_vector, real[], real, real[])
+real student_t_log(row_vector, real[], vector, real)
+real student_t_log(row_vector, real[], vector, vector)
+real student_t_log(row_vector, real[], vector, row_vector)
+real student_t_log(row_vector, real[], vector, real[])
+real student_t_log(row_vector, real[], row_vector, real)
+real student_t_log(row_vector, real[], row_vector, vector)
+real student_t_log(row_vector, real[], row_vector, row_vector)
+real student_t_log(row_vector, real[], row_vector, real[])
+real student_t_log(row_vector, real[], real[], real)
+real student_t_log(row_vector, real[], real[], vector)
+real student_t_log(row_vector, real[], real[], row_vector)
+real student_t_log(row_vector, real[], real[], real[])
+real student_t_log(real[], real, real, vector)
+real student_t_log(real[], real, real, row_vector)
+real student_t_log(real[], real, vector, real)
+real student_t_log(real[], real, vector, vector)
+real student_t_log(real[], real, vector, row_vector)
+real student_t_log(real[], real, vector, real[])
+real student_t_log(real[], real, row_vector, real)
+real student_t_log(real[], real, row_vector, vector)
+real student_t_log(real[], real, row_vector, row_vector)
+real student_t_log(real[], real, row_vector, real[])
+real student_t_log(real[], real, real[], vector)
+real student_t_log(real[], real, real[], row_vector)
+real student_t_log(real[], vector, real, real)
+real student_t_log(real[], vector, real, vector)
+real student_t_log(real[], vector, real, row_vector)
+real student_t_log(real[], vector, real, real[])
+real student_t_log(real[], vector, vector, real)
+real student_t_log(real[], vector, vector, vector)
+real student_t_log(real[], vector, vector, row_vector)
+real student_t_log(real[], vector, vector, real[])
+real student_t_log(real[], vector, row_vector, real)
+real student_t_log(real[], vector, row_vector, vector)
+real student_t_log(real[], vector, row_vector, row_vector)
+real student_t_log(real[], vector, row_vector, real[])
+real student_t_log(real[], vector, real[], real)
+real student_t_log(real[], vector, real[], vector)
+real student_t_log(real[], vector, real[], row_vector)
+real student_t_log(real[], vector, real[], real[])
+real student_t_log(real[], row_vector, real, real)
+real student_t_log(real[], row_vector, real, vector)
+real student_t_log(real[], row_vector, real, row_vector)
+real student_t_log(real[], row_vector, real, real[])
+real student_t_log(real[], row_vector, vector, real)
+real student_t_log(real[], row_vector, vector, vector)
+real student_t_log(real[], row_vector, vector, row_vector)
+real student_t_log(real[], row_vector, vector, real[])
+real student_t_log(real[], row_vector, row_vector, real)
+real student_t_log(real[], row_vector, row_vector, vector)
+real student_t_log(real[], row_vector, row_vector, row_vector)
+real student_t_log(real[], row_vector, row_vector, real[])
+real student_t_log(real[], row_vector, real[], real)
+real student_t_log(real[], row_vector, real[], vector)
+real student_t_log(real[], row_vector, real[], row_vector)
+real student_t_log(real[], row_vector, real[], real[])
+real student_t_log(real[], real[], real, vector)
+real student_t_log(real[], real[], real, row_vector)
+real student_t_log(real[], real[], vector, real)
+real student_t_log(real[], real[], vector, vector)
+real student_t_log(real[], real[], vector, row_vector)
+real student_t_log(real[], real[], vector, real[])
+real student_t_log(real[], real[], row_vector, real)
+real student_t_log(real[], real[], row_vector, vector)
+real student_t_log(real[], real[], row_vector, row_vector)
+real student_t_log(real[], real[], row_vector, real[])
+real student_t_log(real[], real[], real[], vector)
+real student_t_log(real[], real[], real[], row_vector)
+real student_t_lpdf(real, real, real, vector)
+real student_t_lpdf(real, real, real, row_vector)
+real student_t_lpdf(real, real, vector, real)
+real student_t_lpdf(real, real, vector, vector)
+real student_t_lpdf(real, real, vector, row_vector)
+real student_t_lpdf(real, real, vector, real[])
+real student_t_lpdf(real, real, row_vector, real)
+real student_t_lpdf(real, real, row_vector, vector)
+real student_t_lpdf(real, real, row_vector, row_vector)
+real student_t_lpdf(real, real, row_vector, real[])
+real student_t_lpdf(real, real, real[], vector)
+real student_t_lpdf(real, real, real[], row_vector)
+real student_t_lpdf(real, vector, real, real)
+real student_t_lpdf(real, vector, real, vector)
+real student_t_lpdf(real, vector, real, row_vector)
+real student_t_lpdf(real, vector, real, real[])
+real student_t_lpdf(real, vector, vector, real)
+real student_t_lpdf(real, vector, vector, vector)
+real student_t_lpdf(real, vector, vector, row_vector)
+real student_t_lpdf(real, vector, vector, real[])
+real student_t_lpdf(real, vector, row_vector, real)
+real student_t_lpdf(real, vector, row_vector, vector)
+real student_t_lpdf(real, vector, row_vector, row_vector)
+real student_t_lpdf(real, vector, row_vector, real[])
+real student_t_lpdf(real, vector, real[], real)
+real student_t_lpdf(real, vector, real[], vector)
+real student_t_lpdf(real, vector, real[], row_vector)
+real student_t_lpdf(real, vector, real[], real[])
+real student_t_lpdf(real, row_vector, real, real)
+real student_t_lpdf(real, row_vector, real, vector)
+real student_t_lpdf(real, row_vector, real, row_vector)
+real student_t_lpdf(real, row_vector, real, real[])
+real student_t_lpdf(real, row_vector, vector, real)
+real student_t_lpdf(real, row_vector, vector, vector)
+real student_t_lpdf(real, row_vector, vector, row_vector)
+real student_t_lpdf(real, row_vector, vector, real[])
+real student_t_lpdf(real, row_vector, row_vector, real)
+real student_t_lpdf(real, row_vector, row_vector, vector)
+real student_t_lpdf(real, row_vector, row_vector, row_vector)
+real student_t_lpdf(real, row_vector, row_vector, real[])
+real student_t_lpdf(real, row_vector, real[], real)
+real student_t_lpdf(real, row_vector, real[], vector)
+real student_t_lpdf(real, row_vector, real[], row_vector)
+real student_t_lpdf(real, row_vector, real[], real[])
+real student_t_lpdf(real, real[], real, vector)
+real student_t_lpdf(real, real[], real, row_vector)
+real student_t_lpdf(real, real[], vector, real)
+real student_t_lpdf(real, real[], vector, vector)
+real student_t_lpdf(real, real[], vector, row_vector)
+real student_t_lpdf(real, real[], vector, real[])
+real student_t_lpdf(real, real[], row_vector, real)
+real student_t_lpdf(real, real[], row_vector, vector)
+real student_t_lpdf(real, real[], row_vector, row_vector)
+real student_t_lpdf(real, real[], row_vector, real[])
+real student_t_lpdf(real, real[], real[], vector)
+real student_t_lpdf(real, real[], real[], row_vector)
+real student_t_lpdf(vector, real, real, real)
+real student_t_lpdf(vector, real, real, vector)
+real student_t_lpdf(vector, real, real, row_vector)
+real student_t_lpdf(vector, real, real, real[])
+real student_t_lpdf(vector, real, vector, real)
+real student_t_lpdf(vector, real, vector, vector)
+real student_t_lpdf(vector, real, vector, row_vector)
+real student_t_lpdf(vector, real, vector, real[])
+real student_t_lpdf(vector, real, row_vector, real)
+real student_t_lpdf(vector, real, row_vector, vector)
+real student_t_lpdf(vector, real, row_vector, row_vector)
+real student_t_lpdf(vector, real, row_vector, real[])
+real student_t_lpdf(vector, real, real[], real)
+real student_t_lpdf(vector, real, real[], vector)
+real student_t_lpdf(vector, real, real[], row_vector)
+real student_t_lpdf(vector, real, real[], real[])
+real student_t_lpdf(vector, vector, real, real)
+real student_t_lpdf(vector, vector, real, vector)
+real student_t_lpdf(vector, vector, real, row_vector)
+real student_t_lpdf(vector, vector, real, real[])
+real student_t_lpdf(vector, vector, vector, real)
+real student_t_lpdf(vector, vector, vector, vector)
+real student_t_lpdf(vector, vector, vector, row_vector)
+real student_t_lpdf(vector, vector, vector, real[])
+real student_t_lpdf(vector, vector, row_vector, real)
+real student_t_lpdf(vector, vector, row_vector, vector)
+real student_t_lpdf(vector, vector, row_vector, row_vector)
+real student_t_lpdf(vector, vector, row_vector, real[])
+real student_t_lpdf(vector, vector, real[], real)
+real student_t_lpdf(vector, vector, real[], vector)
+real student_t_lpdf(vector, vector, real[], row_vector)
+real student_t_lpdf(vector, vector, real[], real[])
+real student_t_lpdf(vector, row_vector, real, real)
+real student_t_lpdf(vector, row_vector, real, vector)
+real student_t_lpdf(vector, row_vector, real, row_vector)
+real student_t_lpdf(vector, row_vector, real, real[])
+real student_t_lpdf(vector, row_vector, vector, real)
+real student_t_lpdf(vector, row_vector, vector, vector)
+real student_t_lpdf(vector, row_vector, vector, row_vector)
+real student_t_lpdf(vector, row_vector, vector, real[])
+real student_t_lpdf(vector, row_vector, row_vector, real)
+real student_t_lpdf(vector, row_vector, row_vector, vector)
+real student_t_lpdf(vector, row_vector, row_vector, row_vector)
+real student_t_lpdf(vector, row_vector, row_vector, real[])
+real student_t_lpdf(vector, row_vector, real[], real)
+real student_t_lpdf(vector, row_vector, real[], vector)
+real student_t_lpdf(vector, row_vector, real[], row_vector)
+real student_t_lpdf(vector, row_vector, real[], real[])
+real student_t_lpdf(vector, real[], real, real)
+real student_t_lpdf(vector, real[], real, vector)
+real student_t_lpdf(vector, real[], real, row_vector)
+real student_t_lpdf(vector, real[], real, real[])
+real student_t_lpdf(vector, real[], vector, real)
+real student_t_lpdf(vector, real[], vector, vector)
+real student_t_lpdf(vector, real[], vector, row_vector)
+real student_t_lpdf(vector, real[], vector, real[])
+real student_t_lpdf(vector, real[], row_vector, real)
+real student_t_lpdf(vector, real[], row_vector, vector)
+real student_t_lpdf(vector, real[], row_vector, row_vector)
+real student_t_lpdf(vector, real[], row_vector, real[])
+real student_t_lpdf(vector, real[], real[], real)
+real student_t_lpdf(vector, real[], real[], vector)
+real student_t_lpdf(vector, real[], real[], row_vector)
+real student_t_lpdf(vector, real[], real[], real[])
+real student_t_lpdf(row_vector, real, real, real)
+real student_t_lpdf(row_vector, real, real, vector)
+real student_t_lpdf(row_vector, real, real, row_vector)
+real student_t_lpdf(row_vector, real, real, real[])
+real student_t_lpdf(row_vector, real, vector, real)
+real student_t_lpdf(row_vector, real, vector, vector)
+real student_t_lpdf(row_vector, real, vector, row_vector)
+real student_t_lpdf(row_vector, real, vector, real[])
+real student_t_lpdf(row_vector, real, row_vector, real)
+real student_t_lpdf(row_vector, real, row_vector, vector)
+real student_t_lpdf(row_vector, real, row_vector, row_vector)
+real student_t_lpdf(row_vector, real, row_vector, real[])
+real student_t_lpdf(row_vector, real, real[], real)
+real student_t_lpdf(row_vector, real, real[], vector)
+real student_t_lpdf(row_vector, real, real[], row_vector)
+real student_t_lpdf(row_vector, real, real[], real[])
+real student_t_lpdf(row_vector, vector, real, real)
+real student_t_lpdf(row_vector, vector, real, vector)
+real student_t_lpdf(row_vector, vector, real, row_vector)
+real student_t_lpdf(row_vector, vector, real, real[])
+real student_t_lpdf(row_vector, vector, vector, real)
+real student_t_lpdf(row_vector, vector, vector, vector)
+real student_t_lpdf(row_vector, vector, vector, row_vector)
+real student_t_lpdf(row_vector, vector, vector, real[])
+real student_t_lpdf(row_vector, vector, row_vector, real)
+real student_t_lpdf(row_vector, vector, row_vector, vector)
+real student_t_lpdf(row_vector, vector, row_vector, row_vector)
+real student_t_lpdf(row_vector, vector, row_vector, real[])
+real student_t_lpdf(row_vector, vector, real[], real)
+real student_t_lpdf(row_vector, vector, real[], vector)
+real student_t_lpdf(row_vector, vector, real[], row_vector)
+real student_t_lpdf(row_vector, vector, real[], real[])
+real student_t_lpdf(row_vector, row_vector, real, real)
+real student_t_lpdf(row_vector, row_vector, real, vector)
+real student_t_lpdf(row_vector, row_vector, real, row_vector)
+real student_t_lpdf(row_vector, row_vector, real, real[])
+real student_t_lpdf(row_vector, row_vector, vector, real)
+real student_t_lpdf(row_vector, row_vector, vector, vector)
+real student_t_lpdf(row_vector, row_vector, vector, row_vector)
+real student_t_lpdf(row_vector, row_vector, vector, real[])
+real student_t_lpdf(row_vector, row_vector, row_vector, real)
+real student_t_lpdf(row_vector, row_vector, row_vector, vector)
+real student_t_lpdf(row_vector, row_vector, row_vector, row_vector)
+real student_t_lpdf(row_vector, row_vector, row_vector, real[])
+real student_t_lpdf(row_vector, row_vector, real[], real)
+real student_t_lpdf(row_vector, row_vector, real[], vector)
+real student_t_lpdf(row_vector, row_vector, real[], row_vector)
+real student_t_lpdf(row_vector, row_vector, real[], real[])
+real student_t_lpdf(row_vector, real[], real, real)
+real student_t_lpdf(row_vector, real[], real, vector)
+real student_t_lpdf(row_vector, real[], real, row_vector)
+real student_t_lpdf(row_vector, real[], real, real[])
+real student_t_lpdf(row_vector, real[], vector, real)
+real student_t_lpdf(row_vector, real[], vector, vector)
+real student_t_lpdf(row_vector, real[], vector, row_vector)
+real student_t_lpdf(row_vector, real[], vector, real[])
+real student_t_lpdf(row_vector, real[], row_vector, real)
+real student_t_lpdf(row_vector, real[], row_vector, vector)
+real student_t_lpdf(row_vector, real[], row_vector, row_vector)
+real student_t_lpdf(row_vector, real[], row_vector, real[])
+real student_t_lpdf(row_vector, real[], real[], real)
+real student_t_lpdf(row_vector, real[], real[], vector)
+real student_t_lpdf(row_vector, real[], real[], row_vector)
+real student_t_lpdf(row_vector, real[], real[], real[])
+real student_t_lpdf(real[], real, real, vector)
+real student_t_lpdf(real[], real, real, row_vector)
+real student_t_lpdf(real[], real, vector, real)
+real student_t_lpdf(real[], real, vector, vector)
+real student_t_lpdf(real[], real, vector, row_vector)
+real student_t_lpdf(real[], real, vector, real[])
+real student_t_lpdf(real[], real, row_vector, real)
+real student_t_lpdf(real[], real, row_vector, vector)
+real student_t_lpdf(real[], real, row_vector, row_vector)
+real student_t_lpdf(real[], real, row_vector, real[])
+real student_t_lpdf(real[], real, real[], vector)
+real student_t_lpdf(real[], real, real[], row_vector)
+real student_t_lpdf(real[], vector, real, real)
+real student_t_lpdf(real[], vector, real, vector)
+real student_t_lpdf(real[], vector, real, row_vector)
+real student_t_lpdf(real[], vector, real, real[])
+real student_t_lpdf(real[], vector, vector, real)
+real student_t_lpdf(real[], vector, vector, vector)
+real student_t_lpdf(real[], vector, vector, row_vector)
+real student_t_lpdf(real[], vector, vector, real[])
+real student_t_lpdf(real[], vector, row_vector, real)
+real student_t_lpdf(real[], vector, row_vector, vector)
+real student_t_lpdf(real[], vector, row_vector, row_vector)
+real student_t_lpdf(real[], vector, row_vector, real[])
+real student_t_lpdf(real[], vector, real[], real)
+real student_t_lpdf(real[], vector, real[], vector)
+real student_t_lpdf(real[], vector, real[], row_vector)
+real student_t_lpdf(real[], vector, real[], real[])
+real student_t_lpdf(real[], row_vector, real, real)
+real student_t_lpdf(real[], row_vector, real, vector)
+real student_t_lpdf(real[], row_vector, real, row_vector)
+real student_t_lpdf(real[], row_vector, real, real[])
+real student_t_lpdf(real[], row_vector, vector, real)
+real student_t_lpdf(real[], row_vector, vector, vector)
+real student_t_lpdf(real[], row_vector, vector, row_vector)
+real student_t_lpdf(real[], row_vector, vector, real[])
+real student_t_lpdf(real[], row_vector, row_vector, real)
+real student_t_lpdf(real[], row_vector, row_vector, vector)
+real student_t_lpdf(real[], row_vector, row_vector, row_vector)
+real student_t_lpdf(real[], row_vector, row_vector, real[])
+real student_t_lpdf(real[], row_vector, real[], real)
+real student_t_lpdf(real[], row_vector, real[], vector)
+real student_t_lpdf(real[], row_vector, real[], row_vector)
+real student_t_lpdf(real[], row_vector, real[], real[])
+real student_t_lpdf(real[], real[], real, vector)
+real student_t_lpdf(real[], real[], real, row_vector)
+real student_t_lpdf(real[], real[], vector, real)
+real student_t_lpdf(real[], real[], vector, vector)
+real student_t_lpdf(real[], real[], vector, row_vector)
+real student_t_lpdf(real[], real[], vector, real[])
+real student_t_lpdf(real[], real[], row_vector, real)
+real student_t_lpdf(real[], real[], row_vector, vector)
+real student_t_lpdf(real[], real[], row_vector, row_vector)
+real student_t_lpdf(real[], real[], row_vector, real[])
+real student_t_lpdf(real[], real[], real[], vector)
+real student_t_lpdf(real[], real[], real[], row_vector)
+real[] student_t_rng(int, int, vector)
+real[] student_t_rng(int, int, row_vector)
+real[] student_t_rng(int, real, vector)
+real[] student_t_rng(int, real, row_vector)
+real[] student_t_rng(int, vector, int)
+real[] student_t_rng(int, vector, real)
+real[] student_t_rng(int, vector, vector)
+real[] student_t_rng(int, vector, row_vector)
+real[] student_t_rng(int, vector, int[])
+real[] student_t_rng(int, vector, real[])
+real[] student_t_rng(int, row_vector, int)
+real[] student_t_rng(int, row_vector, real)
+real[] student_t_rng(int, row_vector, vector)
+real[] student_t_rng(int, row_vector, row_vector)
+real[] student_t_rng(int, row_vector, int[])
+real[] student_t_rng(int, row_vector, real[])
+real[] student_t_rng(int, int[], vector)
+real[] student_t_rng(int, int[], row_vector)
+real[] student_t_rng(int, real[], vector)
+real[] student_t_rng(int, real[], row_vector)
+real[] student_t_rng(real, int, vector)
+real[] student_t_rng(real, int, row_vector)
+real[] student_t_rng(real, real, vector)
+real[] student_t_rng(real, real, row_vector)
+real[] student_t_rng(real, vector, int)
+real[] student_t_rng(real, vector, real)
+real[] student_t_rng(real, vector, vector)
+real[] student_t_rng(real, vector, row_vector)
+real[] student_t_rng(real, vector, int[])
+real[] student_t_rng(real, vector, real[])
+real[] student_t_rng(real, row_vector, int)
+real[] student_t_rng(real, row_vector, real)
+real[] student_t_rng(real, row_vector, vector)
+real[] student_t_rng(real, row_vector, row_vector)
+real[] student_t_rng(real, row_vector, int[])
+real[] student_t_rng(real, row_vector, real[])
+real[] student_t_rng(real, int[], vector)
+real[] student_t_rng(real, int[], row_vector)
+real[] student_t_rng(real, real[], vector)
+real[] student_t_rng(real, real[], row_vector)
+real[] student_t_rng(vector, int, int)
+real[] student_t_rng(vector, int, real)
+real[] student_t_rng(vector, int, vector)
+real[] student_t_rng(vector, int, row_vector)
+real[] student_t_rng(vector, int, int[])
+real[] student_t_rng(vector, int, real[])
+real[] student_t_rng(vector, real, int)
+real[] student_t_rng(vector, real, real)
+real[] student_t_rng(vector, real, vector)
+real[] student_t_rng(vector, real, row_vector)
+real[] student_t_rng(vector, real, int[])
+real[] student_t_rng(vector, real, real[])
+real[] student_t_rng(vector, vector, int)
+real[] student_t_rng(vector, vector, real)
+real[] student_t_rng(vector, vector, vector)
+real[] student_t_rng(vector, vector, row_vector)
+real[] student_t_rng(vector, vector, int[])
+real[] student_t_rng(vector, vector, real[])
+real[] student_t_rng(vector, row_vector, int)
+real[] student_t_rng(vector, row_vector, real)
+real[] student_t_rng(vector, row_vector, vector)
+real[] student_t_rng(vector, row_vector, row_vector)
+real[] student_t_rng(vector, row_vector, int[])
+real[] student_t_rng(vector, row_vector, real[])
+real[] student_t_rng(vector, int[], int)
+real[] student_t_rng(vector, int[], real)
+real[] student_t_rng(vector, int[], vector)
+real[] student_t_rng(vector, int[], row_vector)
+real[] student_t_rng(vector, int[], int[])
+real[] student_t_rng(vector, int[], real[])
+real[] student_t_rng(vector, real[], int)
+real[] student_t_rng(vector, real[], real)
+real[] student_t_rng(vector, real[], vector)
+real[] student_t_rng(vector, real[], row_vector)
+real[] student_t_rng(vector, real[], int[])
+real[] student_t_rng(vector, real[], real[])
+real[] student_t_rng(row_vector, int, int)
+real[] student_t_rng(row_vector, int, real)
+real[] student_t_rng(row_vector, int, vector)
+real[] student_t_rng(row_vector, int, row_vector)
+real[] student_t_rng(row_vector, int, int[])
+real[] student_t_rng(row_vector, int, real[])
+real[] student_t_rng(row_vector, real, int)
+real[] student_t_rng(row_vector, real, real)
+real[] student_t_rng(row_vector, real, vector)
+real[] student_t_rng(row_vector, real, row_vector)
+real[] student_t_rng(row_vector, real, int[])
+real[] student_t_rng(row_vector, real, real[])
+real[] student_t_rng(row_vector, vector, int)
+real[] student_t_rng(row_vector, vector, real)
+real[] student_t_rng(row_vector, vector, vector)
+real[] student_t_rng(row_vector, vector, row_vector)
+real[] student_t_rng(row_vector, vector, int[])
+real[] student_t_rng(row_vector, vector, real[])
+real[] student_t_rng(row_vector, row_vector, int)
+real[] student_t_rng(row_vector, row_vector, real)
+real[] student_t_rng(row_vector, row_vector, vector)
+real[] student_t_rng(row_vector, row_vector, row_vector)
+real[] student_t_rng(row_vector, row_vector, int[])
+real[] student_t_rng(row_vector, row_vector, real[])
+real[] student_t_rng(row_vector, int[], int)
+real[] student_t_rng(row_vector, int[], real)
+real[] student_t_rng(row_vector, int[], vector)
+real[] student_t_rng(row_vector, int[], row_vector)
+real[] student_t_rng(row_vector, int[], int[])
+real[] student_t_rng(row_vector, int[], real[])
+real[] student_t_rng(row_vector, real[], int)
+real[] student_t_rng(row_vector, real[], real)
+real[] student_t_rng(row_vector, real[], vector)
+real[] student_t_rng(row_vector, real[], row_vector)
+real[] student_t_rng(row_vector, real[], int[])
+real[] student_t_rng(row_vector, real[], real[])
+real[] student_t_rng(int[], int, vector)
+real[] student_t_rng(int[], int, row_vector)
+real[] student_t_rng(int[], real, vector)
+real[] student_t_rng(int[], real, row_vector)
+real[] student_t_rng(int[], vector, int)
+real[] student_t_rng(int[], vector, real)
+real[] student_t_rng(int[], vector, vector)
+real[] student_t_rng(int[], vector, row_vector)
+real[] student_t_rng(int[], vector, int[])
+real[] student_t_rng(int[], vector, real[])
+real[] student_t_rng(int[], row_vector, int)
+real[] student_t_rng(int[], row_vector, real)
+real[] student_t_rng(int[], row_vector, vector)
+real[] student_t_rng(int[], row_vector, row_vector)
+real[] student_t_rng(int[], row_vector, int[])
+real[] student_t_rng(int[], row_vector, real[])
+real[] student_t_rng(int[], int[], vector)
+real[] student_t_rng(int[], int[], row_vector)
+real[] student_t_rng(int[], real[], vector)
+real[] student_t_rng(int[], real[], row_vector)
+real[] student_t_rng(real[], int, vector)
+real[] student_t_rng(real[], int, row_vector)
+real[] student_t_rng(real[], real, vector)
+real[] student_t_rng(real[], real, row_vector)
+real[] student_t_rng(real[], vector, int)
+real[] student_t_rng(real[], vector, real)
+real[] student_t_rng(real[], vector, vector)
+real[] student_t_rng(real[], vector, row_vector)
+real[] student_t_rng(real[], vector, int[])
+real[] student_t_rng(real[], vector, real[])
+real[] student_t_rng(real[], row_vector, int)
+real[] student_t_rng(real[], row_vector, real)
+real[] student_t_rng(real[], row_vector, vector)
+real[] student_t_rng(real[], row_vector, row_vector)
+real[] student_t_rng(real[], row_vector, int[])
+real[] student_t_rng(real[], row_vector, real[])
+real[] student_t_rng(real[], int[], vector)
+real[] student_t_rng(real[], int[], row_vector)
+real[] student_t_rng(real[], real[], vector)
+real[] student_t_rng(real[], real[], row_vector)
+real uniform_ccdf_log(real, real, vector)
+real uniform_ccdf_log(real, real, row_vector)
+real uniform_ccdf_log(real, vector, real)
+real uniform_ccdf_log(real, vector, vector)
+real uniform_ccdf_log(real, vector, row_vector)
+real uniform_ccdf_log(real, vector, real[])
+real uniform_ccdf_log(real, row_vector, real)
+real uniform_ccdf_log(real, row_vector, vector)
+real uniform_ccdf_log(real, row_vector, row_vector)
+real uniform_ccdf_log(real, row_vector, real[])
+real uniform_ccdf_log(real, real[], vector)
+real uniform_ccdf_log(real, real[], row_vector)
+real uniform_ccdf_log(vector, real, real)
+real uniform_ccdf_log(vector, real, vector)
+real uniform_ccdf_log(vector, real, row_vector)
+real uniform_ccdf_log(vector, real, real[])
+real uniform_ccdf_log(vector, vector, real)
+real uniform_ccdf_log(vector, vector, vector)
+real uniform_ccdf_log(vector, vector, row_vector)
+real uniform_ccdf_log(vector, vector, real[])
+real uniform_ccdf_log(vector, row_vector, real)
+real uniform_ccdf_log(vector, row_vector, vector)
+real uniform_ccdf_log(vector, row_vector, row_vector)
+real uniform_ccdf_log(vector, row_vector, real[])
+real uniform_ccdf_log(vector, real[], real)
+real uniform_ccdf_log(vector, real[], vector)
+real uniform_ccdf_log(vector, real[], row_vector)
+real uniform_ccdf_log(vector, real[], real[])
+real uniform_ccdf_log(row_vector, real, real)
+real uniform_ccdf_log(row_vector, real, vector)
+real uniform_ccdf_log(row_vector, real, row_vector)
+real uniform_ccdf_log(row_vector, real, real[])
+real uniform_ccdf_log(row_vector, vector, real)
+real uniform_ccdf_log(row_vector, vector, vector)
+real uniform_ccdf_log(row_vector, vector, row_vector)
+real uniform_ccdf_log(row_vector, vector, real[])
+real uniform_ccdf_log(row_vector, row_vector, real)
+real uniform_ccdf_log(row_vector, row_vector, vector)
+real uniform_ccdf_log(row_vector, row_vector, row_vector)
+real uniform_ccdf_log(row_vector, row_vector, real[])
+real uniform_ccdf_log(row_vector, real[], real)
+real uniform_ccdf_log(row_vector, real[], vector)
+real uniform_ccdf_log(row_vector, real[], row_vector)
+real uniform_ccdf_log(row_vector, real[], real[])
+real uniform_ccdf_log(real[], real, vector)
+real uniform_ccdf_log(real[], real, row_vector)
+real uniform_ccdf_log(real[], vector, real)
+real uniform_ccdf_log(real[], vector, vector)
+real uniform_ccdf_log(real[], vector, row_vector)
+real uniform_ccdf_log(real[], vector, real[])
+real uniform_ccdf_log(real[], row_vector, real)
+real uniform_ccdf_log(real[], row_vector, vector)
+real uniform_ccdf_log(real[], row_vector, row_vector)
+real uniform_ccdf_log(real[], row_vector, real[])
+real uniform_ccdf_log(real[], real[], vector)
+real uniform_ccdf_log(real[], real[], row_vector)
+real uniform_cdf(real, real, vector)
+real uniform_cdf(real, real, row_vector)
+real uniform_cdf(real, vector, real)
+real uniform_cdf(real, vector, vector)
+real uniform_cdf(real, vector, row_vector)
+real uniform_cdf(real, vector, real[])
+real uniform_cdf(real, row_vector, real)
+real uniform_cdf(real, row_vector, vector)
+real uniform_cdf(real, row_vector, row_vector)
+real uniform_cdf(real, row_vector, real[])
+real uniform_cdf(real, real[], vector)
+real uniform_cdf(real, real[], row_vector)
+real uniform_cdf(vector, real, real)
+real uniform_cdf(vector, real, vector)
+real uniform_cdf(vector, real, row_vector)
+real uniform_cdf(vector, real, real[])
+real uniform_cdf(vector, vector, real)
+real uniform_cdf(vector, vector, vector)
+real uniform_cdf(vector, vector, row_vector)
+real uniform_cdf(vector, vector, real[])
+real uniform_cdf(vector, row_vector, real)
+real uniform_cdf(vector, row_vector, vector)
+real uniform_cdf(vector, row_vector, row_vector)
+real uniform_cdf(vector, row_vector, real[])
+real uniform_cdf(vector, real[], real)
+real uniform_cdf(vector, real[], vector)
+real uniform_cdf(vector, real[], row_vector)
+real uniform_cdf(vector, real[], real[])
+real uniform_cdf(row_vector, real, real)
+real uniform_cdf(row_vector, real, vector)
+real uniform_cdf(row_vector, real, row_vector)
+real uniform_cdf(row_vector, real, real[])
+real uniform_cdf(row_vector, vector, real)
+real uniform_cdf(row_vector, vector, vector)
+real uniform_cdf(row_vector, vector, row_vector)
+real uniform_cdf(row_vector, vector, real[])
+real uniform_cdf(row_vector, row_vector, real)
+real uniform_cdf(row_vector, row_vector, vector)
+real uniform_cdf(row_vector, row_vector, row_vector)
+real uniform_cdf(row_vector, row_vector, real[])
+real uniform_cdf(row_vector, real[], real)
+real uniform_cdf(row_vector, real[], vector)
+real uniform_cdf(row_vector, real[], row_vector)
+real uniform_cdf(row_vector, real[], real[])
+real uniform_cdf(real[], real, vector)
+real uniform_cdf(real[], real, row_vector)
+real uniform_cdf(real[], vector, real)
+real uniform_cdf(real[], vector, vector)
+real uniform_cdf(real[], vector, row_vector)
+real uniform_cdf(real[], vector, real[])
+real uniform_cdf(real[], row_vector, real)
+real uniform_cdf(real[], row_vector, vector)
+real uniform_cdf(real[], row_vector, row_vector)
+real uniform_cdf(real[], row_vector, real[])
+real uniform_cdf(real[], real[], vector)
+real uniform_cdf(real[], real[], row_vector)
+real uniform_cdf_log(real, real, vector)
+real uniform_cdf_log(real, real, row_vector)
+real uniform_cdf_log(real, vector, real)
+real uniform_cdf_log(real, vector, vector)
+real uniform_cdf_log(real, vector, row_vector)
+real uniform_cdf_log(real, vector, real[])
+real uniform_cdf_log(real, row_vector, real)
+real uniform_cdf_log(real, row_vector, vector)
+real uniform_cdf_log(real, row_vector, row_vector)
+real uniform_cdf_log(real, row_vector, real[])
+real uniform_cdf_log(real, real[], vector)
+real uniform_cdf_log(real, real[], row_vector)
+real uniform_cdf_log(vector, real, real)
+real uniform_cdf_log(vector, real, vector)
+real uniform_cdf_log(vector, real, row_vector)
+real uniform_cdf_log(vector, real, real[])
+real uniform_cdf_log(vector, vector, real)
+real uniform_cdf_log(vector, vector, vector)
+real uniform_cdf_log(vector, vector, row_vector)
+real uniform_cdf_log(vector, vector, real[])
+real uniform_cdf_log(vector, row_vector, real)
+real uniform_cdf_log(vector, row_vector, vector)
+real uniform_cdf_log(vector, row_vector, row_vector)
+real uniform_cdf_log(vector, row_vector, real[])
+real uniform_cdf_log(vector, real[], real)
+real uniform_cdf_log(vector, real[], vector)
+real uniform_cdf_log(vector, real[], row_vector)
+real uniform_cdf_log(vector, real[], real[])
+real uniform_cdf_log(row_vector, real, real)
+real uniform_cdf_log(row_vector, real, vector)
+real uniform_cdf_log(row_vector, real, row_vector)
+real uniform_cdf_log(row_vector, real, real[])
+real uniform_cdf_log(row_vector, vector, real)
+real uniform_cdf_log(row_vector, vector, vector)
+real uniform_cdf_log(row_vector, vector, row_vector)
+real uniform_cdf_log(row_vector, vector, real[])
+real uniform_cdf_log(row_vector, row_vector, real)
+real uniform_cdf_log(row_vector, row_vector, vector)
+real uniform_cdf_log(row_vector, row_vector, row_vector)
+real uniform_cdf_log(row_vector, row_vector, real[])
+real uniform_cdf_log(row_vector, real[], real)
+real uniform_cdf_log(row_vector, real[], vector)
+real uniform_cdf_log(row_vector, real[], row_vector)
+real uniform_cdf_log(row_vector, real[], real[])
+real uniform_cdf_log(real[], real, vector)
+real uniform_cdf_log(real[], real, row_vector)
+real uniform_cdf_log(real[], vector, real)
+real uniform_cdf_log(real[], vector, vector)
+real uniform_cdf_log(real[], vector, row_vector)
+real uniform_cdf_log(real[], vector, real[])
+real uniform_cdf_log(real[], row_vector, real)
+real uniform_cdf_log(real[], row_vector, vector)
+real uniform_cdf_log(real[], row_vector, row_vector)
+real uniform_cdf_log(real[], row_vector, real[])
+real uniform_cdf_log(real[], real[], vector)
+real uniform_cdf_log(real[], real[], row_vector)
+real uniform_lccdf(real, real, vector)
+real uniform_lccdf(real, real, row_vector)
+real uniform_lccdf(real, vector, real)
+real uniform_lccdf(real, vector, vector)
+real uniform_lccdf(real, vector, row_vector)
+real uniform_lccdf(real, vector, real[])
+real uniform_lccdf(real, row_vector, real)
+real uniform_lccdf(real, row_vector, vector)
+real uniform_lccdf(real, row_vector, row_vector)
+real uniform_lccdf(real, row_vector, real[])
+real uniform_lccdf(real, real[], vector)
+real uniform_lccdf(real, real[], row_vector)
+real uniform_lccdf(vector, real, real)
+real uniform_lccdf(vector, real, vector)
+real uniform_lccdf(vector, real, row_vector)
+real uniform_lccdf(vector, real, real[])
+real uniform_lccdf(vector, vector, real)
+real uniform_lccdf(vector, vector, vector)
+real uniform_lccdf(vector, vector, row_vector)
+real uniform_lccdf(vector, vector, real[])
+real uniform_lccdf(vector, row_vector, real)
+real uniform_lccdf(vector, row_vector, vector)
+real uniform_lccdf(vector, row_vector, row_vector)
+real uniform_lccdf(vector, row_vector, real[])
+real uniform_lccdf(vector, real[], real)
+real uniform_lccdf(vector, real[], vector)
+real uniform_lccdf(vector, real[], row_vector)
+real uniform_lccdf(vector, real[], real[])
+real uniform_lccdf(row_vector, real, real)
+real uniform_lccdf(row_vector, real, vector)
+real uniform_lccdf(row_vector, real, row_vector)
+real uniform_lccdf(row_vector, real, real[])
+real uniform_lccdf(row_vector, vector, real)
+real uniform_lccdf(row_vector, vector, vector)
+real uniform_lccdf(row_vector, vector, row_vector)
+real uniform_lccdf(row_vector, vector, real[])
+real uniform_lccdf(row_vector, row_vector, real)
+real uniform_lccdf(row_vector, row_vector, vector)
+real uniform_lccdf(row_vector, row_vector, row_vector)
+real uniform_lccdf(row_vector, row_vector, real[])
+real uniform_lccdf(row_vector, real[], real)
+real uniform_lccdf(row_vector, real[], vector)
+real uniform_lccdf(row_vector, real[], row_vector)
+real uniform_lccdf(row_vector, real[], real[])
+real uniform_lccdf(real[], real, vector)
+real uniform_lccdf(real[], real, row_vector)
+real uniform_lccdf(real[], vector, real)
+real uniform_lccdf(real[], vector, vector)
+real uniform_lccdf(real[], vector, row_vector)
+real uniform_lccdf(real[], vector, real[])
+real uniform_lccdf(real[], row_vector, real)
+real uniform_lccdf(real[], row_vector, vector)
+real uniform_lccdf(real[], row_vector, row_vector)
+real uniform_lccdf(real[], row_vector, real[])
+real uniform_lccdf(real[], real[], vector)
+real uniform_lccdf(real[], real[], row_vector)
+real uniform_lcdf(real, real, vector)
+real uniform_lcdf(real, real, row_vector)
+real uniform_lcdf(real, vector, real)
+real uniform_lcdf(real, vector, vector)
+real uniform_lcdf(real, vector, row_vector)
+real uniform_lcdf(real, vector, real[])
+real uniform_lcdf(real, row_vector, real)
+real uniform_lcdf(real, row_vector, vector)
+real uniform_lcdf(real, row_vector, row_vector)
+real uniform_lcdf(real, row_vector, real[])
+real uniform_lcdf(real, real[], vector)
+real uniform_lcdf(real, real[], row_vector)
+real uniform_lcdf(vector, real, real)
+real uniform_lcdf(vector, real, vector)
+real uniform_lcdf(vector, real, row_vector)
+real uniform_lcdf(vector, real, real[])
+real uniform_lcdf(vector, vector, real)
+real uniform_lcdf(vector, vector, vector)
+real uniform_lcdf(vector, vector, row_vector)
+real uniform_lcdf(vector, vector, real[])
+real uniform_lcdf(vector, row_vector, real)
+real uniform_lcdf(vector, row_vector, vector)
+real uniform_lcdf(vector, row_vector, row_vector)
+real uniform_lcdf(vector, row_vector, real[])
+real uniform_lcdf(vector, real[], real)
+real uniform_lcdf(vector, real[], vector)
+real uniform_lcdf(vector, real[], row_vector)
+real uniform_lcdf(vector, real[], real[])
+real uniform_lcdf(row_vector, real, real)
+real uniform_lcdf(row_vector, real, vector)
+real uniform_lcdf(row_vector, real, row_vector)
+real uniform_lcdf(row_vector, real, real[])
+real uniform_lcdf(row_vector, vector, real)
+real uniform_lcdf(row_vector, vector, vector)
+real uniform_lcdf(row_vector, vector, row_vector)
+real uniform_lcdf(row_vector, vector, real[])
+real uniform_lcdf(row_vector, row_vector, real)
+real uniform_lcdf(row_vector, row_vector, vector)
+real uniform_lcdf(row_vector, row_vector, row_vector)
+real uniform_lcdf(row_vector, row_vector, real[])
+real uniform_lcdf(row_vector, real[], real)
+real uniform_lcdf(row_vector, real[], vector)
+real uniform_lcdf(row_vector, real[], row_vector)
+real uniform_lcdf(row_vector, real[], real[])
+real uniform_lcdf(real[], real, vector)
+real uniform_lcdf(real[], real, row_vector)
+real uniform_lcdf(real[], vector, real)
+real uniform_lcdf(real[], vector, vector)
+real uniform_lcdf(real[], vector, row_vector)
+real uniform_lcdf(real[], vector, real[])
+real uniform_lcdf(real[], row_vector, real)
+real uniform_lcdf(real[], row_vector, vector)
+real uniform_lcdf(real[], row_vector, row_vector)
+real uniform_lcdf(real[], row_vector, real[])
+real uniform_lcdf(real[], real[], vector)
+real uniform_lcdf(real[], real[], row_vector)
+real uniform_log(real, real, vector)
+real uniform_log(real, real, row_vector)
+real uniform_log(real, vector, real)
+real uniform_log(real, vector, vector)
+real uniform_log(real, vector, row_vector)
+real uniform_log(real, vector, real[])
+real uniform_log(real, row_vector, real)
+real uniform_log(real, row_vector, vector)
+real uniform_log(real, row_vector, row_vector)
+real uniform_log(real, row_vector, real[])
+real uniform_log(real, real[], vector)
+real uniform_log(real, real[], row_vector)
+real uniform_log(vector, real, real)
+real uniform_log(vector, real, vector)
+real uniform_log(vector, real, row_vector)
+real uniform_log(vector, real, real[])
+real uniform_log(vector, vector, real)
+real uniform_log(vector, vector, vector)
+real uniform_log(vector, vector, row_vector)
+real uniform_log(vector, vector, real[])
+real uniform_log(vector, row_vector, real)
+real uniform_log(vector, row_vector, vector)
+real uniform_log(vector, row_vector, row_vector)
+real uniform_log(vector, row_vector, real[])
+real uniform_log(vector, real[], real)
+real uniform_log(vector, real[], vector)
+real uniform_log(vector, real[], row_vector)
+real uniform_log(vector, real[], real[])
+real uniform_log(row_vector, real, real)
+real uniform_log(row_vector, real, vector)
+real uniform_log(row_vector, real, row_vector)
+real uniform_log(row_vector, real, real[])
+real uniform_log(row_vector, vector, real)
+real uniform_log(row_vector, vector, vector)
+real uniform_log(row_vector, vector, row_vector)
+real uniform_log(row_vector, vector, real[])
+real uniform_log(row_vector, row_vector, real)
+real uniform_log(row_vector, row_vector, vector)
+real uniform_log(row_vector, row_vector, row_vector)
+real uniform_log(row_vector, row_vector, real[])
+real uniform_log(row_vector, real[], real)
+real uniform_log(row_vector, real[], vector)
+real uniform_log(row_vector, real[], row_vector)
+real uniform_log(row_vector, real[], real[])
+real uniform_log(real[], real, vector)
+real uniform_log(real[], real, row_vector)
+real uniform_log(real[], vector, real)
+real uniform_log(real[], vector, vector)
+real uniform_log(real[], vector, row_vector)
+real uniform_log(real[], vector, real[])
+real uniform_log(real[], row_vector, real)
+real uniform_log(real[], row_vector, vector)
+real uniform_log(real[], row_vector, row_vector)
+real uniform_log(real[], row_vector, real[])
+real uniform_log(real[], real[], vector)
+real uniform_log(real[], real[], row_vector)
+real uniform_lpdf(real, real, vector)
+real uniform_lpdf(real, real, row_vector)
+real uniform_lpdf(real, vector, real)
+real uniform_lpdf(real, vector, vector)
+real uniform_lpdf(real, vector, row_vector)
+real uniform_lpdf(real, vector, real[])
+real uniform_lpdf(real, row_vector, real)
+real uniform_lpdf(real, row_vector, vector)
+real uniform_lpdf(real, row_vector, row_vector)
+real uniform_lpdf(real, row_vector, real[])
+real uniform_lpdf(real, real[], vector)
+real uniform_lpdf(real, real[], row_vector)
+real uniform_lpdf(vector, real, real)
+real uniform_lpdf(vector, real, vector)
+real uniform_lpdf(vector, real, row_vector)
+real uniform_lpdf(vector, real, real[])
+real uniform_lpdf(vector, vector, real)
+real uniform_lpdf(vector, vector, vector)
+real uniform_lpdf(vector, vector, row_vector)
+real uniform_lpdf(vector, vector, real[])
+real uniform_lpdf(vector, row_vector, real)
+real uniform_lpdf(vector, row_vector, vector)
+real uniform_lpdf(vector, row_vector, row_vector)
+real uniform_lpdf(vector, row_vector, real[])
+real uniform_lpdf(vector, real[], real)
+real uniform_lpdf(vector, real[], vector)
+real uniform_lpdf(vector, real[], row_vector)
+real uniform_lpdf(vector, real[], real[])
+real uniform_lpdf(row_vector, real, real)
+real uniform_lpdf(row_vector, real, vector)
+real uniform_lpdf(row_vector, real, row_vector)
+real uniform_lpdf(row_vector, real, real[])
+real uniform_lpdf(row_vector, vector, real)
+real uniform_lpdf(row_vector, vector, vector)
+real uniform_lpdf(row_vector, vector, row_vector)
+real uniform_lpdf(row_vector, vector, real[])
+real uniform_lpdf(row_vector, row_vector, real)
+real uniform_lpdf(row_vector, row_vector, vector)
+real uniform_lpdf(row_vector, row_vector, row_vector)
+real uniform_lpdf(row_vector, row_vector, real[])
+real uniform_lpdf(row_vector, real[], real)
+real uniform_lpdf(row_vector, real[], vector)
+real uniform_lpdf(row_vector, real[], row_vector)
+real uniform_lpdf(row_vector, real[], real[])
+real uniform_lpdf(real[], real, vector)
+real uniform_lpdf(real[], real, row_vector)
+real uniform_lpdf(real[], vector, real)
+real uniform_lpdf(real[], vector, vector)
+real uniform_lpdf(real[], vector, row_vector)
+real uniform_lpdf(real[], vector, real[])
+real uniform_lpdf(real[], row_vector, real)
+real uniform_lpdf(real[], row_vector, vector)
+real uniform_lpdf(real[], row_vector, row_vector)
+real uniform_lpdf(real[], row_vector, real[])
+real uniform_lpdf(real[], real[], vector)
+real uniform_lpdf(real[], real[], row_vector)
+real[] uniform_rng(int, vector)
+real[] uniform_rng(int, row_vector)
+real[] uniform_rng(real, vector)
+real[] uniform_rng(real, row_vector)
+real[] uniform_rng(vector, int)
+real[] uniform_rng(vector, real)
+real[] uniform_rng(vector, vector)
+real[] uniform_rng(vector, row_vector)
+real[] uniform_rng(vector, int[])
+real[] uniform_rng(vector, real[])
+real[] uniform_rng(row_vector, int)
+real[] uniform_rng(row_vector, real)
+real[] uniform_rng(row_vector, vector)
+real[] uniform_rng(row_vector, row_vector)
+real[] uniform_rng(row_vector, int[])
+real[] uniform_rng(row_vector, real[])
+real[] uniform_rng(int[], vector)
+real[] uniform_rng(int[], row_vector)
+real[] uniform_rng(real[], vector)
+real[] uniform_rng(real[], row_vector)
+real variance(vector)
+real variance(row_vector)
+real variance(matrix)
+real von_mises_log(real, real, vector)
+real von_mises_log(real, real, row_vector)
+real von_mises_log(real, vector, real)
+real von_mises_log(real, vector, vector)
+real von_mises_log(real, vector, row_vector)
+real von_mises_log(real, vector, real[])
+real von_mises_log(real, row_vector, real)
+real von_mises_log(real, row_vector, vector)
+real von_mises_log(real, row_vector, row_vector)
+real von_mises_log(real, row_vector, real[])
+real von_mises_log(real, real[], vector)
+real von_mises_log(real, real[], row_vector)
+real von_mises_log(vector, real, real)
+real von_mises_log(vector, real, vector)
+real von_mises_log(vector, real, row_vector)
+real von_mises_log(vector, real, real[])
+real von_mises_log(vector, vector, real)
+real von_mises_log(vector, vector, vector)
+real von_mises_log(vector, vector, row_vector)
+real von_mises_log(vector, vector, real[])
+real von_mises_log(vector, row_vector, real)
+real von_mises_log(vector, row_vector, vector)
+real von_mises_log(vector, row_vector, row_vector)
+real von_mises_log(vector, row_vector, real[])
+real von_mises_log(vector, real[], real)
+real von_mises_log(vector, real[], vector)
+real von_mises_log(vector, real[], row_vector)
+real von_mises_log(vector, real[], real[])
+real von_mises_log(row_vector, real, real)
+real von_mises_log(row_vector, real, vector)
+real von_mises_log(row_vector, real, row_vector)
+real von_mises_log(row_vector, real, real[])
+real von_mises_log(row_vector, vector, real)
+real von_mises_log(row_vector, vector, vector)
+real von_mises_log(row_vector, vector, row_vector)
+real von_mises_log(row_vector, vector, real[])
+real von_mises_log(row_vector, row_vector, real)
+real von_mises_log(row_vector, row_vector, vector)
+real von_mises_log(row_vector, row_vector, row_vector)
+real von_mises_log(row_vector, row_vector, real[])
+real von_mises_log(row_vector, real[], real)
+real von_mises_log(row_vector, real[], vector)
+real von_mises_log(row_vector, real[], row_vector)
+real von_mises_log(row_vector, real[], real[])
+real von_mises_log(real[], real, vector)
+real von_mises_log(real[], real, row_vector)
+real von_mises_log(real[], vector, real)
+real von_mises_log(real[], vector, vector)
+real von_mises_log(real[], vector, row_vector)
+real von_mises_log(real[], vector, real[])
+real von_mises_log(real[], row_vector, real)
+real von_mises_log(real[], row_vector, vector)
+real von_mises_log(real[], row_vector, row_vector)
+real von_mises_log(real[], row_vector, real[])
+real von_mises_log(real[], real[], vector)
+real von_mises_log(real[], real[], row_vector)
+real von_mises_lpdf(real, real, vector)
+real von_mises_lpdf(real, real, row_vector)
+real von_mises_lpdf(real, vector, real)
+real von_mises_lpdf(real, vector, vector)
+real von_mises_lpdf(real, vector, row_vector)
+real von_mises_lpdf(real, vector, real[])
+real von_mises_lpdf(real, row_vector, real)
+real von_mises_lpdf(real, row_vector, vector)
+real von_mises_lpdf(real, row_vector, row_vector)
+real von_mises_lpdf(real, row_vector, real[])
+real von_mises_lpdf(real, real[], vector)
+real von_mises_lpdf(real, real[], row_vector)
+real von_mises_lpdf(vector, real, real)
+real von_mises_lpdf(vector, real, vector)
+real von_mises_lpdf(vector, real, row_vector)
+real von_mises_lpdf(vector, real, real[])
+real von_mises_lpdf(vector, vector, real)
+real von_mises_lpdf(vector, vector, vector)
+real von_mises_lpdf(vector, vector, row_vector)
+real von_mises_lpdf(vector, vector, real[])
+real von_mises_lpdf(vector, row_vector, real)
+real von_mises_lpdf(vector, row_vector, vector)
+real von_mises_lpdf(vector, row_vector, row_vector)
+real von_mises_lpdf(vector, row_vector, real[])
+real von_mises_lpdf(vector, real[], real)
+real von_mises_lpdf(vector, real[], vector)
+real von_mises_lpdf(vector, real[], row_vector)
+real von_mises_lpdf(vector, real[], real[])
+real von_mises_lpdf(row_vector, real, real)
+real von_mises_lpdf(row_vector, real, vector)
+real von_mises_lpdf(row_vector, real, row_vector)
+real von_mises_lpdf(row_vector, real, real[])
+real von_mises_lpdf(row_vector, vector, real)
+real von_mises_lpdf(row_vector, vector, vector)
+real von_mises_lpdf(row_vector, vector, row_vector)
+real von_mises_lpdf(row_vector, vector, real[])
+real von_mises_lpdf(row_vector, row_vector, real)
+real von_mises_lpdf(row_vector, row_vector, vector)
+real von_mises_lpdf(row_vector, row_vector, row_vector)
+real von_mises_lpdf(row_vector, row_vector, real[])
+real von_mises_lpdf(row_vector, real[], real)
+real von_mises_lpdf(row_vector, real[], vector)
+real von_mises_lpdf(row_vector, real[], row_vector)
+real von_mises_lpdf(row_vector, real[], real[])
+real von_mises_lpdf(real[], real, vector)
+real von_mises_lpdf(real[], real, row_vector)
+real von_mises_lpdf(real[], vector, real)
+real von_mises_lpdf(real[], vector, vector)
+real von_mises_lpdf(real[], vector, row_vector)
+real von_mises_lpdf(real[], vector, real[])
+real von_mises_lpdf(real[], row_vector, real)
+real von_mises_lpdf(real[], row_vector, vector)
+real von_mises_lpdf(real[], row_vector, row_vector)
+real von_mises_lpdf(real[], row_vector, real[])
+real von_mises_lpdf(real[], real[], vector)
+real von_mises_lpdf(real[], real[], row_vector)
+real[] von_mises_rng(int, vector)
+real[] von_mises_rng(int, row_vector)
+real[] von_mises_rng(real, vector)
+real[] von_mises_rng(real, row_vector)
+real[] von_mises_rng(vector, int)
+real[] von_mises_rng(vector, real)
+real[] von_mises_rng(vector, vector)
+real[] von_mises_rng(vector, row_vector)
+real[] von_mises_rng(vector, int[])
+real[] von_mises_rng(vector, real[])
+real[] von_mises_rng(row_vector, int)
+real[] von_mises_rng(row_vector, real)
+real[] von_mises_rng(row_vector, vector)
+real[] von_mises_rng(row_vector, row_vector)
+real[] von_mises_rng(row_vector, int[])
+real[] von_mises_rng(row_vector, real[])
+real[] von_mises_rng(int[], vector)
+real[] von_mises_rng(int[], row_vector)
+real[] von_mises_rng(real[], vector)
+real[] von_mises_rng(real[], row_vector)
+real weibull_ccdf_log(real, real, vector)
+real weibull_ccdf_log(real, real, row_vector)
+real weibull_ccdf_log(real, vector, real)
+real weibull_ccdf_log(real, vector, vector)
+real weibull_ccdf_log(real, vector, row_vector)
+real weibull_ccdf_log(real, vector, real[])
+real weibull_ccdf_log(real, row_vector, real)
+real weibull_ccdf_log(real, row_vector, vector)
+real weibull_ccdf_log(real, row_vector, row_vector)
+real weibull_ccdf_log(real, row_vector, real[])
+real weibull_ccdf_log(real, real[], vector)
+real weibull_ccdf_log(real, real[], row_vector)
+real weibull_ccdf_log(vector, real, real)
+real weibull_ccdf_log(vector, real, vector)
+real weibull_ccdf_log(vector, real, row_vector)
+real weibull_ccdf_log(vector, real, real[])
+real weibull_ccdf_log(vector, vector, real)
+real weibull_ccdf_log(vector, vector, vector)
+real weibull_ccdf_log(vector, vector, row_vector)
+real weibull_ccdf_log(vector, vector, real[])
+real weibull_ccdf_log(vector, row_vector, real)
+real weibull_ccdf_log(vector, row_vector, vector)
+real weibull_ccdf_log(vector, row_vector, row_vector)
+real weibull_ccdf_log(vector, row_vector, real[])
+real weibull_ccdf_log(vector, real[], real)
+real weibull_ccdf_log(vector, real[], vector)
+real weibull_ccdf_log(vector, real[], row_vector)
+real weibull_ccdf_log(vector, real[], real[])
+real weibull_ccdf_log(row_vector, real, real)
+real weibull_ccdf_log(row_vector, real, vector)
+real weibull_ccdf_log(row_vector, real, row_vector)
+real weibull_ccdf_log(row_vector, real, real[])
+real weibull_ccdf_log(row_vector, vector, real)
+real weibull_ccdf_log(row_vector, vector, vector)
+real weibull_ccdf_log(row_vector, vector, row_vector)
+real weibull_ccdf_log(row_vector, vector, real[])
+real weibull_ccdf_log(row_vector, row_vector, real)
+real weibull_ccdf_log(row_vector, row_vector, vector)
+real weibull_ccdf_log(row_vector, row_vector, row_vector)
+real weibull_ccdf_log(row_vector, row_vector, real[])
+real weibull_ccdf_log(row_vector, real[], real)
+real weibull_ccdf_log(row_vector, real[], vector)
+real weibull_ccdf_log(row_vector, real[], row_vector)
+real weibull_ccdf_log(row_vector, real[], real[])
+real weibull_ccdf_log(real[], real, vector)
+real weibull_ccdf_log(real[], real, row_vector)
+real weibull_ccdf_log(real[], vector, real)
+real weibull_ccdf_log(real[], vector, vector)
+real weibull_ccdf_log(real[], vector, row_vector)
+real weibull_ccdf_log(real[], vector, real[])
+real weibull_ccdf_log(real[], row_vector, real)
+real weibull_ccdf_log(real[], row_vector, vector)
+real weibull_ccdf_log(real[], row_vector, row_vector)
+real weibull_ccdf_log(real[], row_vector, real[])
+real weibull_ccdf_log(real[], real[], vector)
+real weibull_ccdf_log(real[], real[], row_vector)
+real weibull_cdf(real, real, vector)
+real weibull_cdf(real, real, row_vector)
+real weibull_cdf(real, vector, real)
+real weibull_cdf(real, vector, vector)
+real weibull_cdf(real, vector, row_vector)
+real weibull_cdf(real, vector, real[])
+real weibull_cdf(real, row_vector, real)
+real weibull_cdf(real, row_vector, vector)
+real weibull_cdf(real, row_vector, row_vector)
+real weibull_cdf(real, row_vector, real[])
+real weibull_cdf(real, real[], vector)
+real weibull_cdf(real, real[], row_vector)
+real weibull_cdf(vector, real, real)
+real weibull_cdf(vector, real, vector)
+real weibull_cdf(vector, real, row_vector)
+real weibull_cdf(vector, real, real[])
+real weibull_cdf(vector, vector, real)
+real weibull_cdf(vector, vector, vector)
+real weibull_cdf(vector, vector, row_vector)
+real weibull_cdf(vector, vector, real[])
+real weibull_cdf(vector, row_vector, real)
+real weibull_cdf(vector, row_vector, vector)
+real weibull_cdf(vector, row_vector, row_vector)
+real weibull_cdf(vector, row_vector, real[])
+real weibull_cdf(vector, real[], real)
+real weibull_cdf(vector, real[], vector)
+real weibull_cdf(vector, real[], row_vector)
+real weibull_cdf(vector, real[], real[])
+real weibull_cdf(row_vector, real, real)
+real weibull_cdf(row_vector, real, vector)
+real weibull_cdf(row_vector, real, row_vector)
+real weibull_cdf(row_vector, real, real[])
+real weibull_cdf(row_vector, vector, real)
+real weibull_cdf(row_vector, vector, vector)
+real weibull_cdf(row_vector, vector, row_vector)
+real weibull_cdf(row_vector, vector, real[])
+real weibull_cdf(row_vector, row_vector, real)
+real weibull_cdf(row_vector, row_vector, vector)
+real weibull_cdf(row_vector, row_vector, row_vector)
+real weibull_cdf(row_vector, row_vector, real[])
+real weibull_cdf(row_vector, real[], real)
+real weibull_cdf(row_vector, real[], vector)
+real weibull_cdf(row_vector, real[], row_vector)
+real weibull_cdf(row_vector, real[], real[])
+real weibull_cdf(real[], real, vector)
+real weibull_cdf(real[], real, row_vector)
+real weibull_cdf(real[], vector, real)
+real weibull_cdf(real[], vector, vector)
+real weibull_cdf(real[], vector, row_vector)
+real weibull_cdf(real[], vector, real[])
+real weibull_cdf(real[], row_vector, real)
+real weibull_cdf(real[], row_vector, vector)
+real weibull_cdf(real[], row_vector, row_vector)
+real weibull_cdf(real[], row_vector, real[])
+real weibull_cdf(real[], real[], vector)
+real weibull_cdf(real[], real[], row_vector)
+real weibull_cdf_log(real, real, vector)
+real weibull_cdf_log(real, real, row_vector)
+real weibull_cdf_log(real, vector, real)
+real weibull_cdf_log(real, vector, vector)
+real weibull_cdf_log(real, vector, row_vector)
+real weibull_cdf_log(real, vector, real[])
+real weibull_cdf_log(real, row_vector, real)
+real weibull_cdf_log(real, row_vector, vector)
+real weibull_cdf_log(real, row_vector, row_vector)
+real weibull_cdf_log(real, row_vector, real[])
+real weibull_cdf_log(real, real[], vector)
+real weibull_cdf_log(real, real[], row_vector)
+real weibull_cdf_log(vector, real, real)
+real weibull_cdf_log(vector, real, vector)
+real weibull_cdf_log(vector, real, row_vector)
+real weibull_cdf_log(vector, real, real[])
+real weibull_cdf_log(vector, vector, real)
+real weibull_cdf_log(vector, vector, vector)
+real weibull_cdf_log(vector, vector, row_vector)
+real weibull_cdf_log(vector, vector, real[])
+real weibull_cdf_log(vector, row_vector, real)
+real weibull_cdf_log(vector, row_vector, vector)
+real weibull_cdf_log(vector, row_vector, row_vector)
+real weibull_cdf_log(vector, row_vector, real[])
+real weibull_cdf_log(vector, real[], real)
+real weibull_cdf_log(vector, real[], vector)
+real weibull_cdf_log(vector, real[], row_vector)
+real weibull_cdf_log(vector, real[], real[])
+real weibull_cdf_log(row_vector, real, real)
+real weibull_cdf_log(row_vector, real, vector)
+real weibull_cdf_log(row_vector, real, row_vector)
+real weibull_cdf_log(row_vector, real, real[])
+real weibull_cdf_log(row_vector, vector, real)
+real weibull_cdf_log(row_vector, vector, vector)
+real weibull_cdf_log(row_vector, vector, row_vector)
+real weibull_cdf_log(row_vector, vector, real[])
+real weibull_cdf_log(row_vector, row_vector, real)
+real weibull_cdf_log(row_vector, row_vector, vector)
+real weibull_cdf_log(row_vector, row_vector, row_vector)
+real weibull_cdf_log(row_vector, row_vector, real[])
+real weibull_cdf_log(row_vector, real[], real)
+real weibull_cdf_log(row_vector, real[], vector)
+real weibull_cdf_log(row_vector, real[], row_vector)
+real weibull_cdf_log(row_vector, real[], real[])
+real weibull_cdf_log(real[], real, vector)
+real weibull_cdf_log(real[], real, row_vector)
+real weibull_cdf_log(real[], vector, real)
+real weibull_cdf_log(real[], vector, vector)
+real weibull_cdf_log(real[], vector, row_vector)
+real weibull_cdf_log(real[], vector, real[])
+real weibull_cdf_log(real[], row_vector, real)
+real weibull_cdf_log(real[], row_vector, vector)
+real weibull_cdf_log(real[], row_vector, row_vector)
+real weibull_cdf_log(real[], row_vector, real[])
+real weibull_cdf_log(real[], real[], vector)
+real weibull_cdf_log(real[], real[], row_vector)
+real weibull_lccdf(real, real, vector)
+real weibull_lccdf(real, real, row_vector)
+real weibull_lccdf(real, vector, real)
+real weibull_lccdf(real, vector, vector)
+real weibull_lccdf(real, vector, row_vector)
+real weibull_lccdf(real, vector, real[])
+real weibull_lccdf(real, row_vector, real)
+real weibull_lccdf(real, row_vector, vector)
+real weibull_lccdf(real, row_vector, row_vector)
+real weibull_lccdf(real, row_vector, real[])
+real weibull_lccdf(real, real[], vector)
+real weibull_lccdf(real, real[], row_vector)
+real weibull_lccdf(vector, real, real)
+real weibull_lccdf(vector, real, vector)
+real weibull_lccdf(vector, real, row_vector)
+real weibull_lccdf(vector, real, real[])
+real weibull_lccdf(vector, vector, real)
+real weibull_lccdf(vector, vector, vector)
+real weibull_lccdf(vector, vector, row_vector)
+real weibull_lccdf(vector, vector, real[])
+real weibull_lccdf(vector, row_vector, real)
+real weibull_lccdf(vector, row_vector, vector)
+real weibull_lccdf(vector, row_vector, row_vector)
+real weibull_lccdf(vector, row_vector, real[])
+real weibull_lccdf(vector, real[], real)
+real weibull_lccdf(vector, real[], vector)
+real weibull_lccdf(vector, real[], row_vector)
+real weibull_lccdf(vector, real[], real[])
+real weibull_lccdf(row_vector, real, real)
+real weibull_lccdf(row_vector, real, vector)
+real weibull_lccdf(row_vector, real, row_vector)
+real weibull_lccdf(row_vector, real, real[])
+real weibull_lccdf(row_vector, vector, real)
+real weibull_lccdf(row_vector, vector, vector)
+real weibull_lccdf(row_vector, vector, row_vector)
+real weibull_lccdf(row_vector, vector, real[])
+real weibull_lccdf(row_vector, row_vector, real)
+real weibull_lccdf(row_vector, row_vector, vector)
+real weibull_lccdf(row_vector, row_vector, row_vector)
+real weibull_lccdf(row_vector, row_vector, real[])
+real weibull_lccdf(row_vector, real[], real)
+real weibull_lccdf(row_vector, real[], vector)
+real weibull_lccdf(row_vector, real[], row_vector)
+real weibull_lccdf(row_vector, real[], real[])
+real weibull_lccdf(real[], real, vector)
+real weibull_lccdf(real[], real, row_vector)
+real weibull_lccdf(real[], vector, real)
+real weibull_lccdf(real[], vector, vector)
+real weibull_lccdf(real[], vector, row_vector)
+real weibull_lccdf(real[], vector, real[])
+real weibull_lccdf(real[], row_vector, real)
+real weibull_lccdf(real[], row_vector, vector)
+real weibull_lccdf(real[], row_vector, row_vector)
+real weibull_lccdf(real[], row_vector, real[])
+real weibull_lccdf(real[], real[], vector)
+real weibull_lccdf(real[], real[], row_vector)
+real weibull_lcdf(real, real, vector)
+real weibull_lcdf(real, real, row_vector)
+real weibull_lcdf(real, vector, real)
+real weibull_lcdf(real, vector, vector)
+real weibull_lcdf(real, vector, row_vector)
+real weibull_lcdf(real, vector, real[])
+real weibull_lcdf(real, row_vector, real)
+real weibull_lcdf(real, row_vector, vector)
+real weibull_lcdf(real, row_vector, row_vector)
+real weibull_lcdf(real, row_vector, real[])
+real weibull_lcdf(real, real[], vector)
+real weibull_lcdf(real, real[], row_vector)
+real weibull_lcdf(vector, real, real)
+real weibull_lcdf(vector, real, vector)
+real weibull_lcdf(vector, real, row_vector)
+real weibull_lcdf(vector, real, real[])
+real weibull_lcdf(vector, vector, real)
+real weibull_lcdf(vector, vector, vector)
+real weibull_lcdf(vector, vector, row_vector)
+real weibull_lcdf(vector, vector, real[])
+real weibull_lcdf(vector, row_vector, real)
+real weibull_lcdf(vector, row_vector, vector)
+real weibull_lcdf(vector, row_vector, row_vector)
+real weibull_lcdf(vector, row_vector, real[])
+real weibull_lcdf(vector, real[], real)
+real weibull_lcdf(vector, real[], vector)
+real weibull_lcdf(vector, real[], row_vector)
+real weibull_lcdf(vector, real[], real[])
+real weibull_lcdf(row_vector, real, real)
+real weibull_lcdf(row_vector, real, vector)
+real weibull_lcdf(row_vector, real, row_vector)
+real weibull_lcdf(row_vector, real, real[])
+real weibull_lcdf(row_vector, vector, real)
+real weibull_lcdf(row_vector, vector, vector)
+real weibull_lcdf(row_vector, vector, row_vector)
+real weibull_lcdf(row_vector, vector, real[])
+real weibull_lcdf(row_vector, row_vector, real)
+real weibull_lcdf(row_vector, row_vector, vector)
+real weibull_lcdf(row_vector, row_vector, row_vector)
+real weibull_lcdf(row_vector, row_vector, real[])
+real weibull_lcdf(row_vector, real[], real)
+real weibull_lcdf(row_vector, real[], vector)
+real weibull_lcdf(row_vector, real[], row_vector)
+real weibull_lcdf(row_vector, real[], real[])
+real weibull_lcdf(real[], real, vector)
+real weibull_lcdf(real[], real, row_vector)
+real weibull_lcdf(real[], vector, real)
+real weibull_lcdf(real[], vector, vector)
+real weibull_lcdf(real[], vector, row_vector)
+real weibull_lcdf(real[], vector, real[])
+real weibull_lcdf(real[], row_vector, real)
+real weibull_lcdf(real[], row_vector, vector)
+real weibull_lcdf(real[], row_vector, row_vector)
+real weibull_lcdf(real[], row_vector, real[])
+real weibull_lcdf(real[], real[], vector)
+real weibull_lcdf(real[], real[], row_vector)
+real weibull_log(real, real, vector)
+real weibull_log(real, real, row_vector)
+real weibull_log(real, vector, real)
+real weibull_log(real, vector, vector)
+real weibull_log(real, vector, row_vector)
+real weibull_log(real, vector, real[])
+real weibull_log(real, row_vector, real)
+real weibull_log(real, row_vector, vector)
+real weibull_log(real, row_vector, row_vector)
+real weibull_log(real, row_vector, real[])
+real weibull_log(real, real[], vector)
+real weibull_log(real, real[], row_vector)
+real weibull_log(vector, real, real)
+real weibull_log(vector, real, vector)
+real weibull_log(vector, real, row_vector)
+real weibull_log(vector, real, real[])
+real weibull_log(vector, vector, real)
+real weibull_log(vector, vector, vector)
+real weibull_log(vector, vector, row_vector)
+real weibull_log(vector, vector, real[])
+real weibull_log(vector, row_vector, real)
+real weibull_log(vector, row_vector, vector)
+real weibull_log(vector, row_vector, row_vector)
+real weibull_log(vector, row_vector, real[])
+real weibull_log(vector, real[], real)
+real weibull_log(vector, real[], vector)
+real weibull_log(vector, real[], row_vector)
+real weibull_log(vector, real[], real[])
+real weibull_log(row_vector, real, real)
+real weibull_log(row_vector, real, vector)
+real weibull_log(row_vector, real, row_vector)
+real weibull_log(row_vector, real, real[])
+real weibull_log(row_vector, vector, real)
+real weibull_log(row_vector, vector, vector)
+real weibull_log(row_vector, vector, row_vector)
+real weibull_log(row_vector, vector, real[])
+real weibull_log(row_vector, row_vector, real)
+real weibull_log(row_vector, row_vector, vector)
+real weibull_log(row_vector, row_vector, row_vector)
+real weibull_log(row_vector, row_vector, real[])
+real weibull_log(row_vector, real[], real)
+real weibull_log(row_vector, real[], vector)
+real weibull_log(row_vector, real[], row_vector)
+real weibull_log(row_vector, real[], real[])
+real weibull_log(real[], real, vector)
+real weibull_log(real[], real, row_vector)
+real weibull_log(real[], vector, real)
+real weibull_log(real[], vector, vector)
+real weibull_log(real[], vector, row_vector)
+real weibull_log(real[], vector, real[])
+real weibull_log(real[], row_vector, real)
+real weibull_log(real[], row_vector, vector)
+real weibull_log(real[], row_vector, row_vector)
+real weibull_log(real[], row_vector, real[])
+real weibull_log(real[], real[], vector)
+real weibull_log(real[], real[], row_vector)
+real weibull_lpdf(real, real, vector)
+real weibull_lpdf(real, real, row_vector)
+real weibull_lpdf(real, vector, real)
+real weibull_lpdf(real, vector, vector)
+real weibull_lpdf(real, vector, row_vector)
+real weibull_lpdf(real, vector, real[])
+real weibull_lpdf(real, row_vector, real)
+real weibull_lpdf(real, row_vector, vector)
+real weibull_lpdf(real, row_vector, row_vector)
+real weibull_lpdf(real, row_vector, real[])
+real weibull_lpdf(real, real[], vector)
+real weibull_lpdf(real, real[], row_vector)
+real weibull_lpdf(vector, real, real)
+real weibull_lpdf(vector, real, vector)
+real weibull_lpdf(vector, real, row_vector)
+real weibull_lpdf(vector, real, real[])
+real weibull_lpdf(vector, vector, real)
+real weibull_lpdf(vector, vector, vector)
+real weibull_lpdf(vector, vector, row_vector)
+real weibull_lpdf(vector, vector, real[])
+real weibull_lpdf(vector, row_vector, real)
+real weibull_lpdf(vector, row_vector, vector)
+real weibull_lpdf(vector, row_vector, row_vector)
+real weibull_lpdf(vector, row_vector, real[])
+real weibull_lpdf(vector, real[], real)
+real weibull_lpdf(vector, real[], vector)
+real weibull_lpdf(vector, real[], row_vector)
+real weibull_lpdf(vector, real[], real[])
+real weibull_lpdf(row_vector, real, real)
+real weibull_lpdf(row_vector, real, vector)
+real weibull_lpdf(row_vector, real, row_vector)
+real weibull_lpdf(row_vector, real, real[])
+real weibull_lpdf(row_vector, vector, real)
+real weibull_lpdf(row_vector, vector, vector)
+real weibull_lpdf(row_vector, vector, row_vector)
+real weibull_lpdf(row_vector, vector, real[])
+real weibull_lpdf(row_vector, row_vector, real)
+real weibull_lpdf(row_vector, row_vector, vector)
+real weibull_lpdf(row_vector, row_vector, row_vector)
+real weibull_lpdf(row_vector, row_vector, real[])
+real weibull_lpdf(row_vector, real[], real)
+real weibull_lpdf(row_vector, real[], vector)
+real weibull_lpdf(row_vector, real[], row_vector)
+real weibull_lpdf(row_vector, real[], real[])
+real weibull_lpdf(real[], real, vector)
+real weibull_lpdf(real[], real, row_vector)
+real weibull_lpdf(real[], vector, real)
+real weibull_lpdf(real[], vector, vector)
+real weibull_lpdf(real[], vector, row_vector)
+real weibull_lpdf(real[], vector, real[])
+real weibull_lpdf(real[], row_vector, real)
+real weibull_lpdf(real[], row_vector, vector)
+real weibull_lpdf(real[], row_vector, row_vector)
+real weibull_lpdf(real[], row_vector, real[])
+real weibull_lpdf(real[], real[], vector)
+real weibull_lpdf(real[], real[], row_vector)
+real[] weibull_rng(int, vector)
+real[] weibull_rng(int, row_vector)
+real[] weibull_rng(real, vector)
+real[] weibull_rng(real, row_vector)
+real[] weibull_rng(vector, int)
+real[] weibull_rng(vector, real)
+real[] weibull_rng(vector, vector)
+real[] weibull_rng(vector, row_vector)
+real[] weibull_rng(vector, int[])
+real[] weibull_rng(vector, real[])
+real[] weibull_rng(row_vector, int)
+real[] weibull_rng(row_vector, real)
+real[] weibull_rng(row_vector, vector)
+real[] weibull_rng(row_vector, row_vector)
+real[] weibull_rng(row_vector, int[])
+real[] weibull_rng(row_vector, real[])
+real[] weibull_rng(int[], vector)
+real[] weibull_rng(int[], row_vector)
+real[] weibull_rng(real[], vector)
+real[] weibull_rng(real[], row_vector)
+real wiener_log(real, real, real, real, vector)
+real wiener_log(real, real, real, real, row_vector)
+real wiener_log(real, real, real, vector, real)
+real wiener_log(real, real, real, vector, vector)
+real wiener_log(real, real, real, vector, row_vector)
+real wiener_log(real, real, real, vector, real[])
+real wiener_log(real, real, real, row_vector, real)
+real wiener_log(real, real, real, row_vector, vector)
+real wiener_log(real, real, real, row_vector, row_vector)
+real wiener_log(real, real, real, row_vector, real[])
+real wiener_log(real, real, real, real[], vector)
+real wiener_log(real, real, real, real[], row_vector)
+real wiener_log(real, real, vector, real, real)
+real wiener_log(real, real, vector, real, vector)
+real wiener_log(real, real, vector, real, row_vector)
+real wiener_log(real, real, vector, real, real[])
+real wiener_log(real, real, vector, vector, real)
+real wiener_log(real, real, vector, vector, vector)
+real wiener_log(real, real, vector, vector, row_vector)
+real wiener_log(real, real, vector, vector, real[])
+real wiener_log(real, real, vector, row_vector, real)
+real wiener_log(real, real, vector, row_vector, vector)
+real wiener_log(real, real, vector, row_vector, row_vector)
+real wiener_log(real, real, vector, row_vector, real[])
+real wiener_log(real, real, vector, real[], real)
+real wiener_log(real, real, vector, real[], vector)
+real wiener_log(real, real, vector, real[], row_vector)
+real wiener_log(real, real, vector, real[], real[])
+real wiener_log(real, real, row_vector, real, real)
+real wiener_log(real, real, row_vector, real, vector)
+real wiener_log(real, real, row_vector, real, row_vector)
+real wiener_log(real, real, row_vector, real, real[])
+real wiener_log(real, real, row_vector, vector, real)
+real wiener_log(real, real, row_vector, vector, vector)
+real wiener_log(real, real, row_vector, vector, row_vector)
+real wiener_log(real, real, row_vector, vector, real[])
+real wiener_log(real, real, row_vector, row_vector, real)
+real wiener_log(real, real, row_vector, row_vector, vector)
+real wiener_log(real, real, row_vector, row_vector, row_vector)
+real wiener_log(real, real, row_vector, row_vector, real[])
+real wiener_log(real, real, row_vector, real[], real)
+real wiener_log(real, real, row_vector, real[], vector)
+real wiener_log(real, real, row_vector, real[], row_vector)
+real wiener_log(real, real, row_vector, real[], real[])
+real wiener_log(real, real, real[], real, vector)
+real wiener_log(real, real, real[], real, row_vector)
+real wiener_log(real, real, real[], vector, real)
+real wiener_log(real, real, real[], vector, vector)
+real wiener_log(real, real, real[], vector, row_vector)
+real wiener_log(real, real, real[], vector, real[])
+real wiener_log(real, real, real[], row_vector, real)
+real wiener_log(real, real, real[], row_vector, vector)
+real wiener_log(real, real, real[], row_vector, row_vector)
+real wiener_log(real, real, real[], row_vector, real[])
+real wiener_log(real, real, real[], real[], vector)
+real wiener_log(real, real, real[], real[], row_vector)
+real wiener_log(real, vector, real, real, real)
+real wiener_log(real, vector, real, real, vector)
+real wiener_log(real, vector, real, real, row_vector)
+real wiener_log(real, vector, real, real, real[])
+real wiener_log(real, vector, real, vector, real)
+real wiener_log(real, vector, real, vector, vector)
+real wiener_log(real, vector, real, vector, row_vector)
+real wiener_log(real, vector, real, vector, real[])
+real wiener_log(real, vector, real, row_vector, real)
+real wiener_log(real, vector, real, row_vector, vector)
+real wiener_log(real, vector, real, row_vector, row_vector)
+real wiener_log(real, vector, real, row_vector, real[])
+real wiener_log(real, vector, real, real[], real)
+real wiener_log(real, vector, real, real[], vector)
+real wiener_log(real, vector, real, real[], row_vector)
+real wiener_log(real, vector, real, real[], real[])
+real wiener_log(real, vector, vector, real, real)
+real wiener_log(real, vector, vector, real, vector)
+real wiener_log(real, vector, vector, real, row_vector)
+real wiener_log(real, vector, vector, real, real[])
+real wiener_log(real, vector, vector, vector, real)
+real wiener_log(real, vector, vector, vector, vector)
+real wiener_log(real, vector, vector, vector, row_vector)
+real wiener_log(real, vector, vector, vector, real[])
+real wiener_log(real, vector, vector, row_vector, real)
+real wiener_log(real, vector, vector, row_vector, vector)
+real wiener_log(real, vector, vector, row_vector, row_vector)
+real wiener_log(real, vector, vector, row_vector, real[])
+real wiener_log(real, vector, vector, real[], real)
+real wiener_log(real, vector, vector, real[], vector)
+real wiener_log(real, vector, vector, real[], row_vector)
+real wiener_log(real, vector, vector, real[], real[])
+real wiener_log(real, vector, row_vector, real, real)
+real wiener_log(real, vector, row_vector, real, vector)
+real wiener_log(real, vector, row_vector, real, row_vector)
+real wiener_log(real, vector, row_vector, real, real[])
+real wiener_log(real, vector, row_vector, vector, real)
+real wiener_log(real, vector, row_vector, vector, vector)
+real wiener_log(real, vector, row_vector, vector, row_vector)
+real wiener_log(real, vector, row_vector, vector, real[])
+real wiener_log(real, vector, row_vector, row_vector, real)
+real wiener_log(real, vector, row_vector, row_vector, vector)
+real wiener_log(real, vector, row_vector, row_vector, row_vector)
+real wiener_log(real, vector, row_vector, row_vector, real[])
+real wiener_log(real, vector, row_vector, real[], real)
+real wiener_log(real, vector, row_vector, real[], vector)
+real wiener_log(real, vector, row_vector, real[], row_vector)
+real wiener_log(real, vector, row_vector, real[], real[])
+real wiener_log(real, vector, real[], real, real)
+real wiener_log(real, vector, real[], real, vector)
+real wiener_log(real, vector, real[], real, row_vector)
+real wiener_log(real, vector, real[], real, real[])
+real wiener_log(real, vector, real[], vector, real)
+real wiener_log(real, vector, real[], vector, vector)
+real wiener_log(real, vector, real[], vector, row_vector)
+real wiener_log(real, vector, real[], vector, real[])
+real wiener_log(real, vector, real[], row_vector, real)
+real wiener_log(real, vector, real[], row_vector, vector)
+real wiener_log(real, vector, real[], row_vector, row_vector)
+real wiener_log(real, vector, real[], row_vector, real[])
+real wiener_log(real, vector, real[], real[], real)
+real wiener_log(real, vector, real[], real[], vector)
+real wiener_log(real, vector, real[], real[], row_vector)
+real wiener_log(real, vector, real[], real[], real[])
+real wiener_log(real, row_vector, real, real, real)
+real wiener_log(real, row_vector, real, real, vector)
+real wiener_log(real, row_vector, real, real, row_vector)
+real wiener_log(real, row_vector, real, real, real[])
+real wiener_log(real, row_vector, real, vector, real)
+real wiener_log(real, row_vector, real, vector, vector)
+real wiener_log(real, row_vector, real, vector, row_vector)
+real wiener_log(real, row_vector, real, vector, real[])
+real wiener_log(real, row_vector, real, row_vector, real)
+real wiener_log(real, row_vector, real, row_vector, vector)
+real wiener_log(real, row_vector, real, row_vector, row_vector)
+real wiener_log(real, row_vector, real, row_vector, real[])
+real wiener_log(real, row_vector, real, real[], real)
+real wiener_log(real, row_vector, real, real[], vector)
+real wiener_log(real, row_vector, real, real[], row_vector)
+real wiener_log(real, row_vector, real, real[], real[])
+real wiener_log(real, row_vector, vector, real, real)
+real wiener_log(real, row_vector, vector, real, vector)
+real wiener_log(real, row_vector, vector, real, row_vector)
+real wiener_log(real, row_vector, vector, real, real[])
+real wiener_log(real, row_vector, vector, vector, real)
+real wiener_log(real, row_vector, vector, vector, vector)
+real wiener_log(real, row_vector, vector, vector, row_vector)
+real wiener_log(real, row_vector, vector, vector, real[])
+real wiener_log(real, row_vector, vector, row_vector, real)
+real wiener_log(real, row_vector, vector, row_vector, vector)
+real wiener_log(real, row_vector, vector, row_vector, row_vector)
+real wiener_log(real, row_vector, vector, row_vector, real[])
+real wiener_log(real, row_vector, vector, real[], real)
+real wiener_log(real, row_vector, vector, real[], vector)
+real wiener_log(real, row_vector, vector, real[], row_vector)
+real wiener_log(real, row_vector, vector, real[], real[])
+real wiener_log(real, row_vector, row_vector, real, real)
+real wiener_log(real, row_vector, row_vector, real, vector)
+real wiener_log(real, row_vector, row_vector, real, row_vector)
+real wiener_log(real, row_vector, row_vector, real, real[])
+real wiener_log(real, row_vector, row_vector, vector, real)
+real wiener_log(real, row_vector, row_vector, vector, vector)
+real wiener_log(real, row_vector, row_vector, vector, row_vector)
+real wiener_log(real, row_vector, row_vector, vector, real[])
+real wiener_log(real, row_vector, row_vector, row_vector, real)
+real wiener_log(real, row_vector, row_vector, row_vector, vector)
+real wiener_log(real, row_vector, row_vector, row_vector, row_vector)
+real wiener_log(real, row_vector, row_vector, row_vector, real[])
+real wiener_log(real, row_vector, row_vector, real[], real)
+real wiener_log(real, row_vector, row_vector, real[], vector)
+real wiener_log(real, row_vector, row_vector, real[], row_vector)
+real wiener_log(real, row_vector, row_vector, real[], real[])
+real wiener_log(real, row_vector, real[], real, real)
+real wiener_log(real, row_vector, real[], real, vector)
+real wiener_log(real, row_vector, real[], real, row_vector)
+real wiener_log(real, row_vector, real[], real, real[])
+real wiener_log(real, row_vector, real[], vector, real)
+real wiener_log(real, row_vector, real[], vector, vector)
+real wiener_log(real, row_vector, real[], vector, row_vector)
+real wiener_log(real, row_vector, real[], vector, real[])
+real wiener_log(real, row_vector, real[], row_vector, real)
+real wiener_log(real, row_vector, real[], row_vector, vector)
+real wiener_log(real, row_vector, real[], row_vector, row_vector)
+real wiener_log(real, row_vector, real[], row_vector, real[])
+real wiener_log(real, row_vector, real[], real[], real)
+real wiener_log(real, row_vector, real[], real[], vector)
+real wiener_log(real, row_vector, real[], real[], row_vector)
+real wiener_log(real, row_vector, real[], real[], real[])
+real wiener_log(real, real[], real, real, vector)
+real wiener_log(real, real[], real, real, row_vector)
+real wiener_log(real, real[], real, vector, real)
+real wiener_log(real, real[], real, vector, vector)
+real wiener_log(real, real[], real, vector, row_vector)
+real wiener_log(real, real[], real, vector, real[])
+real wiener_log(real, real[], real, row_vector, real)
+real wiener_log(real, real[], real, row_vector, vector)
+real wiener_log(real, real[], real, row_vector, row_vector)
+real wiener_log(real, real[], real, row_vector, real[])
+real wiener_log(real, real[], real, real[], vector)
+real wiener_log(real, real[], real, real[], row_vector)
+real wiener_log(real, real[], vector, real, real)
+real wiener_log(real, real[], vector, real, vector)
+real wiener_log(real, real[], vector, real, row_vector)
+real wiener_log(real, real[], vector, real, real[])
+real wiener_log(real, real[], vector, vector, real)
+real wiener_log(real, real[], vector, vector, vector)
+real wiener_log(real, real[], vector, vector, row_vector)
+real wiener_log(real, real[], vector, vector, real[])
+real wiener_log(real, real[], vector, row_vector, real)
+real wiener_log(real, real[], vector, row_vector, vector)
+real wiener_log(real, real[], vector, row_vector, row_vector)
+real wiener_log(real, real[], vector, row_vector, real[])
+real wiener_log(real, real[], vector, real[], real)
+real wiener_log(real, real[], vector, real[], vector)
+real wiener_log(real, real[], vector, real[], row_vector)
+real wiener_log(real, real[], vector, real[], real[])
+real wiener_log(real, real[], row_vector, real, real)
+real wiener_log(real, real[], row_vector, real, vector)
+real wiener_log(real, real[], row_vector, real, row_vector)
+real wiener_log(real, real[], row_vector, real, real[])
+real wiener_log(real, real[], row_vector, vector, real)
+real wiener_log(real, real[], row_vector, vector, vector)
+real wiener_log(real, real[], row_vector, vector, row_vector)
+real wiener_log(real, real[], row_vector, vector, real[])
+real wiener_log(real, real[], row_vector, row_vector, real)
+real wiener_log(real, real[], row_vector, row_vector, vector)
+real wiener_log(real, real[], row_vector, row_vector, row_vector)
+real wiener_log(real, real[], row_vector, row_vector, real[])
+real wiener_log(real, real[], row_vector, real[], real)
+real wiener_log(real, real[], row_vector, real[], vector)
+real wiener_log(real, real[], row_vector, real[], row_vector)
+real wiener_log(real, real[], row_vector, real[], real[])
+real wiener_log(real, real[], real[], real, vector)
+real wiener_log(real, real[], real[], real, row_vector)
+real wiener_log(real, real[], real[], vector, real)
+real wiener_log(real, real[], real[], vector, vector)
+real wiener_log(real, real[], real[], vector, row_vector)
+real wiener_log(real, real[], real[], vector, real[])
+real wiener_log(real, real[], real[], row_vector, real)
+real wiener_log(real, real[], real[], row_vector, vector)
+real wiener_log(real, real[], real[], row_vector, row_vector)
+real wiener_log(real, real[], real[], row_vector, real[])
+real wiener_log(real, real[], real[], real[], vector)
+real wiener_log(real, real[], real[], real[], row_vector)
+real wiener_log(vector, real, real, real, real)
+real wiener_log(vector, real, real, real, vector)
+real wiener_log(vector, real, real, real, row_vector)
+real wiener_log(vector, real, real, real, real[])
+real wiener_log(vector, real, real, vector, real)
+real wiener_log(vector, real, real, vector, vector)
+real wiener_log(vector, real, real, vector, row_vector)
+real wiener_log(vector, real, real, vector, real[])
+real wiener_log(vector, real, real, row_vector, real)
+real wiener_log(vector, real, real, row_vector, vector)
+real wiener_log(vector, real, real, row_vector, row_vector)
+real wiener_log(vector, real, real, row_vector, real[])
+real wiener_log(vector, real, real, real[], real)
+real wiener_log(vector, real, real, real[], vector)
+real wiener_log(vector, real, real, real[], row_vector)
+real wiener_log(vector, real, real, real[], real[])
+real wiener_log(vector, real, vector, real, real)
+real wiener_log(vector, real, vector, real, vector)
+real wiener_log(vector, real, vector, real, row_vector)
+real wiener_log(vector, real, vector, real, real[])
+real wiener_log(vector, real, vector, vector, real)
+real wiener_log(vector, real, vector, vector, vector)
+real wiener_log(vector, real, vector, vector, row_vector)
+real wiener_log(vector, real, vector, vector, real[])
+real wiener_log(vector, real, vector, row_vector, real)
+real wiener_log(vector, real, vector, row_vector, vector)
+real wiener_log(vector, real, vector, row_vector, row_vector)
+real wiener_log(vector, real, vector, row_vector, real[])
+real wiener_log(vector, real, vector, real[], real)
+real wiener_log(vector, real, vector, real[], vector)
+real wiener_log(vector, real, vector, real[], row_vector)
+real wiener_log(vector, real, vector, real[], real[])
+real wiener_log(vector, real, row_vector, real, real)
+real wiener_log(vector, real, row_vector, real, vector)
+real wiener_log(vector, real, row_vector, real, row_vector)
+real wiener_log(vector, real, row_vector, real, real[])
+real wiener_log(vector, real, row_vector, vector, real)
+real wiener_log(vector, real, row_vector, vector, vector)
+real wiener_log(vector, real, row_vector, vector, row_vector)
+real wiener_log(vector, real, row_vector, vector, real[])
+real wiener_log(vector, real, row_vector, row_vector, real)
+real wiener_log(vector, real, row_vector, row_vector, vector)
+real wiener_log(vector, real, row_vector, row_vector, row_vector)
+real wiener_log(vector, real, row_vector, row_vector, real[])
+real wiener_log(vector, real, row_vector, real[], real)
+real wiener_log(vector, real, row_vector, real[], vector)
+real wiener_log(vector, real, row_vector, real[], row_vector)
+real wiener_log(vector, real, row_vector, real[], real[])
+real wiener_log(vector, real, real[], real, real)
+real wiener_log(vector, real, real[], real, vector)
+real wiener_log(vector, real, real[], real, row_vector)
+real wiener_log(vector, real, real[], real, real[])
+real wiener_log(vector, real, real[], vector, real)
+real wiener_log(vector, real, real[], vector, vector)
+real wiener_log(vector, real, real[], vector, row_vector)
+real wiener_log(vector, real, real[], vector, real[])
+real wiener_log(vector, real, real[], row_vector, real)
+real wiener_log(vector, real, real[], row_vector, vector)
+real wiener_log(vector, real, real[], row_vector, row_vector)
+real wiener_log(vector, real, real[], row_vector, real[])
+real wiener_log(vector, real, real[], real[], real)
+real wiener_log(vector, real, real[], real[], vector)
+real wiener_log(vector, real, real[], real[], row_vector)
+real wiener_log(vector, real, real[], real[], real[])
+real wiener_log(vector, vector, real, real, real)
+real wiener_log(vector, vector, real, real, vector)
+real wiener_log(vector, vector, real, real, row_vector)
+real wiener_log(vector, vector, real, real, real[])
+real wiener_log(vector, vector, real, vector, real)
+real wiener_log(vector, vector, real, vector, vector)
+real wiener_log(vector, vector, real, vector, row_vector)
+real wiener_log(vector, vector, real, vector, real[])
+real wiener_log(vector, vector, real, row_vector, real)
+real wiener_log(vector, vector, real, row_vector, vector)
+real wiener_log(vector, vector, real, row_vector, row_vector)
+real wiener_log(vector, vector, real, row_vector, real[])
+real wiener_log(vector, vector, real, real[], real)
+real wiener_log(vector, vector, real, real[], vector)
+real wiener_log(vector, vector, real, real[], row_vector)
+real wiener_log(vector, vector, real, real[], real[])
+real wiener_log(vector, vector, vector, real, real)
+real wiener_log(vector, vector, vector, real, vector)
+real wiener_log(vector, vector, vector, real, row_vector)
+real wiener_log(vector, vector, vector, real, real[])
+real wiener_log(vector, vector, vector, vector, real)
+real wiener_log(vector, vector, vector, vector, vector)
+real wiener_log(vector, vector, vector, vector, row_vector)
+real wiener_log(vector, vector, vector, vector, real[])
+real wiener_log(vector, vector, vector, row_vector, real)
+real wiener_log(vector, vector, vector, row_vector, vector)
+real wiener_log(vector, vector, vector, row_vector, row_vector)
+real wiener_log(vector, vector, vector, row_vector, real[])
+real wiener_log(vector, vector, vector, real[], real)
+real wiener_log(vector, vector, vector, real[], vector)
+real wiener_log(vector, vector, vector, real[], row_vector)
+real wiener_log(vector, vector, vector, real[], real[])
+real wiener_log(vector, vector, row_vector, real, real)
+real wiener_log(vector, vector, row_vector, real, vector)
+real wiener_log(vector, vector, row_vector, real, row_vector)
+real wiener_log(vector, vector, row_vector, real, real[])
+real wiener_log(vector, vector, row_vector, vector, real)
+real wiener_log(vector, vector, row_vector, vector, vector)
+real wiener_log(vector, vector, row_vector, vector, row_vector)
+real wiener_log(vector, vector, row_vector, vector, real[])
+real wiener_log(vector, vector, row_vector, row_vector, real)
+real wiener_log(vector, vector, row_vector, row_vector, vector)
+real wiener_log(vector, vector, row_vector, row_vector, row_vector)
+real wiener_log(vector, vector, row_vector, row_vector, real[])
+real wiener_log(vector, vector, row_vector, real[], real)
+real wiener_log(vector, vector, row_vector, real[], vector)
+real wiener_log(vector, vector, row_vector, real[], row_vector)
+real wiener_log(vector, vector, row_vector, real[], real[])
+real wiener_log(vector, vector, real[], real, real)
+real wiener_log(vector, vector, real[], real, vector)
+real wiener_log(vector, vector, real[], real, row_vector)
+real wiener_log(vector, vector, real[], real, real[])
+real wiener_log(vector, vector, real[], vector, real)
+real wiener_log(vector, vector, real[], vector, vector)
+real wiener_log(vector, vector, real[], vector, row_vector)
+real wiener_log(vector, vector, real[], vector, real[])
+real wiener_log(vector, vector, real[], row_vector, real)
+real wiener_log(vector, vector, real[], row_vector, vector)
+real wiener_log(vector, vector, real[], row_vector, row_vector)
+real wiener_log(vector, vector, real[], row_vector, real[])
+real wiener_log(vector, vector, real[], real[], real)
+real wiener_log(vector, vector, real[], real[], vector)
+real wiener_log(vector, vector, real[], real[], row_vector)
+real wiener_log(vector, vector, real[], real[], real[])
+real wiener_log(vector, row_vector, real, real, real)
+real wiener_log(vector, row_vector, real, real, vector)
+real wiener_log(vector, row_vector, real, real, row_vector)
+real wiener_log(vector, row_vector, real, real, real[])
+real wiener_log(vector, row_vector, real, vector, real)
+real wiener_log(vector, row_vector, real, vector, vector)
+real wiener_log(vector, row_vector, real, vector, row_vector)
+real wiener_log(vector, row_vector, real, vector, real[])
+real wiener_log(vector, row_vector, real, row_vector, real)
+real wiener_log(vector, row_vector, real, row_vector, vector)
+real wiener_log(vector, row_vector, real, row_vector, row_vector)
+real wiener_log(vector, row_vector, real, row_vector, real[])
+real wiener_log(vector, row_vector, real, real[], real)
+real wiener_log(vector, row_vector, real, real[], vector)
+real wiener_log(vector, row_vector, real, real[], row_vector)
+real wiener_log(vector, row_vector, real, real[], real[])
+real wiener_log(vector, row_vector, vector, real, real)
+real wiener_log(vector, row_vector, vector, real, vector)
+real wiener_log(vector, row_vector, vector, real, row_vector)
+real wiener_log(vector, row_vector, vector, real, real[])
+real wiener_log(vector, row_vector, vector, vector, real)
+real wiener_log(vector, row_vector, vector, vector, vector)
+real wiener_log(vector, row_vector, vector, vector, row_vector)
+real wiener_log(vector, row_vector, vector, vector, real[])
+real wiener_log(vector, row_vector, vector, row_vector, real)
+real wiener_log(vector, row_vector, vector, row_vector, vector)
+real wiener_log(vector, row_vector, vector, row_vector, row_vector)
+real wiener_log(vector, row_vector, vector, row_vector, real[])
+real wiener_log(vector, row_vector, vector, real[], real)
+real wiener_log(vector, row_vector, vector, real[], vector)
+real wiener_log(vector, row_vector, vector, real[], row_vector)
+real wiener_log(vector, row_vector, vector, real[], real[])
+real wiener_log(vector, row_vector, row_vector, real, real)
+real wiener_log(vector, row_vector, row_vector, real, vector)
+real wiener_log(vector, row_vector, row_vector, real, row_vector)
+real wiener_log(vector, row_vector, row_vector, real, real[])
+real wiener_log(vector, row_vector, row_vector, vector, real)
+real wiener_log(vector, row_vector, row_vector, vector, vector)
+real wiener_log(vector, row_vector, row_vector, vector, row_vector)
+real wiener_log(vector, row_vector, row_vector, vector, real[])
+real wiener_log(vector, row_vector, row_vector, row_vector, real)
+real wiener_log(vector, row_vector, row_vector, row_vector, vector)
+real wiener_log(vector, row_vector, row_vector, row_vector, row_vector)
+real wiener_log(vector, row_vector, row_vector, row_vector, real[])
+real wiener_log(vector, row_vector, row_vector, real[], real)
+real wiener_log(vector, row_vector, row_vector, real[], vector)
+real wiener_log(vector, row_vector, row_vector, real[], row_vector)
+real wiener_log(vector, row_vector, row_vector, real[], real[])
+real wiener_log(vector, row_vector, real[], real, real)
+real wiener_log(vector, row_vector, real[], real, vector)
+real wiener_log(vector, row_vector, real[], real, row_vector)
+real wiener_log(vector, row_vector, real[], real, real[])
+real wiener_log(vector, row_vector, real[], vector, real)
+real wiener_log(vector, row_vector, real[], vector, vector)
+real wiener_log(vector, row_vector, real[], vector, row_vector)
+real wiener_log(vector, row_vector, real[], vector, real[])
+real wiener_log(vector, row_vector, real[], row_vector, real)
+real wiener_log(vector, row_vector, real[], row_vector, vector)
+real wiener_log(vector, row_vector, real[], row_vector, row_vector)
+real wiener_log(vector, row_vector, real[], row_vector, real[])
+real wiener_log(vector, row_vector, real[], real[], real)
+real wiener_log(vector, row_vector, real[], real[], vector)
+real wiener_log(vector, row_vector, real[], real[], row_vector)
+real wiener_log(vector, row_vector, real[], real[], real[])
+real wiener_log(vector, real[], real, real, real)
+real wiener_log(vector, real[], real, real, vector)
+real wiener_log(vector, real[], real, real, row_vector)
+real wiener_log(vector, real[], real, real, real[])
+real wiener_log(vector, real[], real, vector, real)
+real wiener_log(vector, real[], real, vector, vector)
+real wiener_log(vector, real[], real, vector, row_vector)
+real wiener_log(vector, real[], real, vector, real[])
+real wiener_log(vector, real[], real, row_vector, real)
+real wiener_log(vector, real[], real, row_vector, vector)
+real wiener_log(vector, real[], real, row_vector, row_vector)
+real wiener_log(vector, real[], real, row_vector, real[])
+real wiener_log(vector, real[], real, real[], real)
+real wiener_log(vector, real[], real, real[], vector)
+real wiener_log(vector, real[], real, real[], row_vector)
+real wiener_log(vector, real[], real, real[], real[])
+real wiener_log(vector, real[], vector, real, real)
+real wiener_log(vector, real[], vector, real, vector)
+real wiener_log(vector, real[], vector, real, row_vector)
+real wiener_log(vector, real[], vector, real, real[])
+real wiener_log(vector, real[], vector, vector, real)
+real wiener_log(vector, real[], vector, vector, vector)
+real wiener_log(vector, real[], vector, vector, row_vector)
+real wiener_log(vector, real[], vector, vector, real[])
+real wiener_log(vector, real[], vector, row_vector, real)
+real wiener_log(vector, real[], vector, row_vector, vector)
+real wiener_log(vector, real[], vector, row_vector, row_vector)
+real wiener_log(vector, real[], vector, row_vector, real[])
+real wiener_log(vector, real[], vector, real[], real)
+real wiener_log(vector, real[], vector, real[], vector)
+real wiener_log(vector, real[], vector, real[], row_vector)
+real wiener_log(vector, real[], vector, real[], real[])
+real wiener_log(vector, real[], row_vector, real, real)
+real wiener_log(vector, real[], row_vector, real, vector)
+real wiener_log(vector, real[], row_vector, real, row_vector)
+real wiener_log(vector, real[], row_vector, real, real[])
+real wiener_log(vector, real[], row_vector, vector, real)
+real wiener_log(vector, real[], row_vector, vector, vector)
+real wiener_log(vector, real[], row_vector, vector, row_vector)
+real wiener_log(vector, real[], row_vector, vector, real[])
+real wiener_log(vector, real[], row_vector, row_vector, real)
+real wiener_log(vector, real[], row_vector, row_vector, vector)
+real wiener_log(vector, real[], row_vector, row_vector, row_vector)
+real wiener_log(vector, real[], row_vector, row_vector, real[])
+real wiener_log(vector, real[], row_vector, real[], real)
+real wiener_log(vector, real[], row_vector, real[], vector)
+real wiener_log(vector, real[], row_vector, real[], row_vector)
+real wiener_log(vector, real[], row_vector, real[], real[])
+real wiener_log(vector, real[], real[], real, real)
+real wiener_log(vector, real[], real[], real, vector)
+real wiener_log(vector, real[], real[], real, row_vector)
+real wiener_log(vector, real[], real[], real, real[])
+real wiener_log(vector, real[], real[], vector, real)
+real wiener_log(vector, real[], real[], vector, vector)
+real wiener_log(vector, real[], real[], vector, row_vector)
+real wiener_log(vector, real[], real[], vector, real[])
+real wiener_log(vector, real[], real[], row_vector, real)
+real wiener_log(vector, real[], real[], row_vector, vector)
+real wiener_log(vector, real[], real[], row_vector, row_vector)
+real wiener_log(vector, real[], real[], row_vector, real[])
+real wiener_log(vector, real[], real[], real[], real)
+real wiener_log(vector, real[], real[], real[], vector)
+real wiener_log(vector, real[], real[], real[], row_vector)
+real wiener_log(vector, real[], real[], real[], real[])
+real wiener_log(row_vector, real, real, real, real)
+real wiener_log(row_vector, real, real, real, vector)
+real wiener_log(row_vector, real, real, real, row_vector)
+real wiener_log(row_vector, real, real, real, real[])
+real wiener_log(row_vector, real, real, vector, real)
+real wiener_log(row_vector, real, real, vector, vector)
+real wiener_log(row_vector, real, real, vector, row_vector)
+real wiener_log(row_vector, real, real, vector, real[])
+real wiener_log(row_vector, real, real, row_vector, real)
+real wiener_log(row_vector, real, real, row_vector, vector)
+real wiener_log(row_vector, real, real, row_vector, row_vector)
+real wiener_log(row_vector, real, real, row_vector, real[])
+real wiener_log(row_vector, real, real, real[], real)
+real wiener_log(row_vector, real, real, real[], vector)
+real wiener_log(row_vector, real, real, real[], row_vector)
+real wiener_log(row_vector, real, real, real[], real[])
+real wiener_log(row_vector, real, vector, real, real)
+real wiener_log(row_vector, real, vector, real, vector)
+real wiener_log(row_vector, real, vector, real, row_vector)
+real wiener_log(row_vector, real, vector, real, real[])
+real wiener_log(row_vector, real, vector, vector, real)
+real wiener_log(row_vector, real, vector, vector, vector)
+real wiener_log(row_vector, real, vector, vector, row_vector)
+real wiener_log(row_vector, real, vector, vector, real[])
+real wiener_log(row_vector, real, vector, row_vector, real)
+real wiener_log(row_vector, real, vector, row_vector, vector)
+real wiener_log(row_vector, real, vector, row_vector, row_vector)
+real wiener_log(row_vector, real, vector, row_vector, real[])
+real wiener_log(row_vector, real, vector, real[], real)
+real wiener_log(row_vector, real, vector, real[], vector)
+real wiener_log(row_vector, real, vector, real[], row_vector)
+real wiener_log(row_vector, real, vector, real[], real[])
+real wiener_log(row_vector, real, row_vector, real, real)
+real wiener_log(row_vector, real, row_vector, real, vector)
+real wiener_log(row_vector, real, row_vector, real, row_vector)
+real wiener_log(row_vector, real, row_vector, real, real[])
+real wiener_log(row_vector, real, row_vector, vector, real)
+real wiener_log(row_vector, real, row_vector, vector, vector)
+real wiener_log(row_vector, real, row_vector, vector, row_vector)
+real wiener_log(row_vector, real, row_vector, vector, real[])
+real wiener_log(row_vector, real, row_vector, row_vector, real)
+real wiener_log(row_vector, real, row_vector, row_vector, vector)
+real wiener_log(row_vector, real, row_vector, row_vector, row_vector)
+real wiener_log(row_vector, real, row_vector, row_vector, real[])
+real wiener_log(row_vector, real, row_vector, real[], real)
+real wiener_log(row_vector, real, row_vector, real[], vector)
+real wiener_log(row_vector, real, row_vector, real[], row_vector)
+real wiener_log(row_vector, real, row_vector, real[], real[])
+real wiener_log(row_vector, real, real[], real, real)
+real wiener_log(row_vector, real, real[], real, vector)
+real wiener_log(row_vector, real, real[], real, row_vector)
+real wiener_log(row_vector, real, real[], real, real[])
+real wiener_log(row_vector, real, real[], vector, real)
+real wiener_log(row_vector, real, real[], vector, vector)
+real wiener_log(row_vector, real, real[], vector, row_vector)
+real wiener_log(row_vector, real, real[], vector, real[])
+real wiener_log(row_vector, real, real[], row_vector, real)
+real wiener_log(row_vector, real, real[], row_vector, vector)
+real wiener_log(row_vector, real, real[], row_vector, row_vector)
+real wiener_log(row_vector, real, real[], row_vector, real[])
+real wiener_log(row_vector, real, real[], real[], real)
+real wiener_log(row_vector, real, real[], real[], vector)
+real wiener_log(row_vector, real, real[], real[], row_vector)
+real wiener_log(row_vector, real, real[], real[], real[])
+real wiener_log(row_vector, vector, real, real, real)
+real wiener_log(row_vector, vector, real, real, vector)
+real wiener_log(row_vector, vector, real, real, row_vector)
+real wiener_log(row_vector, vector, real, real, real[])
+real wiener_log(row_vector, vector, real, vector, real)
+real wiener_log(row_vector, vector, real, vector, vector)
+real wiener_log(row_vector, vector, real, vector, row_vector)
+real wiener_log(row_vector, vector, real, vector, real[])
+real wiener_log(row_vector, vector, real, row_vector, real)
+real wiener_log(row_vector, vector, real, row_vector, vector)
+real wiener_log(row_vector, vector, real, row_vector, row_vector)
+real wiener_log(row_vector, vector, real, row_vector, real[])
+real wiener_log(row_vector, vector, real, real[], real)
+real wiener_log(row_vector, vector, real, real[], vector)
+real wiener_log(row_vector, vector, real, real[], row_vector)
+real wiener_log(row_vector, vector, real, real[], real[])
+real wiener_log(row_vector, vector, vector, real, real)
+real wiener_log(row_vector, vector, vector, real, vector)
+real wiener_log(row_vector, vector, vector, real, row_vector)
+real wiener_log(row_vector, vector, vector, real, real[])
+real wiener_log(row_vector, vector, vector, vector, real)
+real wiener_log(row_vector, vector, vector, vector, vector)
+real wiener_log(row_vector, vector, vector, vector, row_vector)
+real wiener_log(row_vector, vector, vector, vector, real[])
+real wiener_log(row_vector, vector, vector, row_vector, real)
+real wiener_log(row_vector, vector, vector, row_vector, vector)
+real wiener_log(row_vector, vector, vector, row_vector, row_vector)
+real wiener_log(row_vector, vector, vector, row_vector, real[])
+real wiener_log(row_vector, vector, vector, real[], real)
+real wiener_log(row_vector, vector, vector, real[], vector)
+real wiener_log(row_vector, vector, vector, real[], row_vector)
+real wiener_log(row_vector, vector, vector, real[], real[])
+real wiener_log(row_vector, vector, row_vector, real, real)
+real wiener_log(row_vector, vector, row_vector, real, vector)
+real wiener_log(row_vector, vector, row_vector, real, row_vector)
+real wiener_log(row_vector, vector, row_vector, real, real[])
+real wiener_log(row_vector, vector, row_vector, vector, real)
+real wiener_log(row_vector, vector, row_vector, vector, vector)
+real wiener_log(row_vector, vector, row_vector, vector, row_vector)
+real wiener_log(row_vector, vector, row_vector, vector, real[])
+real wiener_log(row_vector, vector, row_vector, row_vector, real)
+real wiener_log(row_vector, vector, row_vector, row_vector, vector)
+real wiener_log(row_vector, vector, row_vector, row_vector, row_vector)
+real wiener_log(row_vector, vector, row_vector, row_vector, real[])
+real wiener_log(row_vector, vector, row_vector, real[], real)
+real wiener_log(row_vector, vector, row_vector, real[], vector)
+real wiener_log(row_vector, vector, row_vector, real[], row_vector)
+real wiener_log(row_vector, vector, row_vector, real[], real[])
+real wiener_log(row_vector, vector, real[], real, real)
+real wiener_log(row_vector, vector, real[], real, vector)
+real wiener_log(row_vector, vector, real[], real, row_vector)
+real wiener_log(row_vector, vector, real[], real, real[])
+real wiener_log(row_vector, vector, real[], vector, real)
+real wiener_log(row_vector, vector, real[], vector, vector)
+real wiener_log(row_vector, vector, real[], vector, row_vector)
+real wiener_log(row_vector, vector, real[], vector, real[])
+real wiener_log(row_vector, vector, real[], row_vector, real)
+real wiener_log(row_vector, vector, real[], row_vector, vector)
+real wiener_log(row_vector, vector, real[], row_vector, row_vector)
+real wiener_log(row_vector, vector, real[], row_vector, real[])
+real wiener_log(row_vector, vector, real[], real[], real)
+real wiener_log(row_vector, vector, real[], real[], vector)
+real wiener_log(row_vector, vector, real[], real[], row_vector)
+real wiener_log(row_vector, vector, real[], real[], real[])
+real wiener_log(row_vector, row_vector, real, real, real)
+real wiener_log(row_vector, row_vector, real, real, vector)
+real wiener_log(row_vector, row_vector, real, real, row_vector)
+real wiener_log(row_vector, row_vector, real, real, real[])
+real wiener_log(row_vector, row_vector, real, vector, real)
+real wiener_log(row_vector, row_vector, real, vector, vector)
+real wiener_log(row_vector, row_vector, real, vector, row_vector)
+real wiener_log(row_vector, row_vector, real, vector, real[])
+real wiener_log(row_vector, row_vector, real, row_vector, real)
+real wiener_log(row_vector, row_vector, real, row_vector, vector)
+real wiener_log(row_vector, row_vector, real, row_vector, row_vector)
+real wiener_log(row_vector, row_vector, real, row_vector, real[])
+real wiener_log(row_vector, row_vector, real, real[], real)
+real wiener_log(row_vector, row_vector, real, real[], vector)
+real wiener_log(row_vector, row_vector, real, real[], row_vector)
+real wiener_log(row_vector, row_vector, real, real[], real[])
+real wiener_log(row_vector, row_vector, vector, real, real)
+real wiener_log(row_vector, row_vector, vector, real, vector)
+real wiener_log(row_vector, row_vector, vector, real, row_vector)
+real wiener_log(row_vector, row_vector, vector, real, real[])
+real wiener_log(row_vector, row_vector, vector, vector, real)
+real wiener_log(row_vector, row_vector, vector, vector, vector)
+real wiener_log(row_vector, row_vector, vector, vector, row_vector)
+real wiener_log(row_vector, row_vector, vector, vector, real[])
+real wiener_log(row_vector, row_vector, vector, row_vector, real)
+real wiener_log(row_vector, row_vector, vector, row_vector, vector)
+real wiener_log(row_vector, row_vector, vector, row_vector, row_vector)
+real wiener_log(row_vector, row_vector, vector, row_vector, real[])
+real wiener_log(row_vector, row_vector, vector, real[], real)
+real wiener_log(row_vector, row_vector, vector, real[], vector)
+real wiener_log(row_vector, row_vector, vector, real[], row_vector)
+real wiener_log(row_vector, row_vector, vector, real[], real[])
+real wiener_log(row_vector, row_vector, row_vector, real, real)
+real wiener_log(row_vector, row_vector, row_vector, real, vector)
+real wiener_log(row_vector, row_vector, row_vector, real, row_vector)
+real wiener_log(row_vector, row_vector, row_vector, real, real[])
+real wiener_log(row_vector, row_vector, row_vector, vector, real)
+real wiener_log(row_vector, row_vector, row_vector, vector, vector)
+real wiener_log(row_vector, row_vector, row_vector, vector, row_vector)
+real wiener_log(row_vector, row_vector, row_vector, vector, real[])
+real wiener_log(row_vector, row_vector, row_vector, row_vector, real)
+real wiener_log(row_vector, row_vector, row_vector, row_vector, vector)
+real wiener_log(row_vector, row_vector, row_vector, row_vector, row_vector)
+real wiener_log(row_vector, row_vector, row_vector, row_vector, real[])
+real wiener_log(row_vector, row_vector, row_vector, real[], real)
+real wiener_log(row_vector, row_vector, row_vector, real[], vector)
+real wiener_log(row_vector, row_vector, row_vector, real[], row_vector)
+real wiener_log(row_vector, row_vector, row_vector, real[], real[])
+real wiener_log(row_vector, row_vector, real[], real, real)
+real wiener_log(row_vector, row_vector, real[], real, vector)
+real wiener_log(row_vector, row_vector, real[], real, row_vector)
+real wiener_log(row_vector, row_vector, real[], real, real[])
+real wiener_log(row_vector, row_vector, real[], vector, real)
+real wiener_log(row_vector, row_vector, real[], vector, vector)
+real wiener_log(row_vector, row_vector, real[], vector, row_vector)
+real wiener_log(row_vector, row_vector, real[], vector, real[])
+real wiener_log(row_vector, row_vector, real[], row_vector, real)
+real wiener_log(row_vector, row_vector, real[], row_vector, vector)
+real wiener_log(row_vector, row_vector, real[], row_vector, row_vector)
+real wiener_log(row_vector, row_vector, real[], row_vector, real[])
+real wiener_log(row_vector, row_vector, real[], real[], real)
+real wiener_log(row_vector, row_vector, real[], real[], vector)
+real wiener_log(row_vector, row_vector, real[], real[], row_vector)
+real wiener_log(row_vector, row_vector, real[], real[], real[])
+real wiener_log(row_vector, real[], real, real, real)
+real wiener_log(row_vector, real[], real, real, vector)
+real wiener_log(row_vector, real[], real, real, row_vector)
+real wiener_log(row_vector, real[], real, real, real[])
+real wiener_log(row_vector, real[], real, vector, real)
+real wiener_log(row_vector, real[], real, vector, vector)
+real wiener_log(row_vector, real[], real, vector, row_vector)
+real wiener_log(row_vector, real[], real, vector, real[])
+real wiener_log(row_vector, real[], real, row_vector, real)
+real wiener_log(row_vector, real[], real, row_vector, vector)
+real wiener_log(row_vector, real[], real, row_vector, row_vector)
+real wiener_log(row_vector, real[], real, row_vector, real[])
+real wiener_log(row_vector, real[], real, real[], real)
+real wiener_log(row_vector, real[], real, real[], vector)
+real wiener_log(row_vector, real[], real, real[], row_vector)
+real wiener_log(row_vector, real[], real, real[], real[])
+real wiener_log(row_vector, real[], vector, real, real)
+real wiener_log(row_vector, real[], vector, real, vector)
+real wiener_log(row_vector, real[], vector, real, row_vector)
+real wiener_log(row_vector, real[], vector, real, real[])
+real wiener_log(row_vector, real[], vector, vector, real)
+real wiener_log(row_vector, real[], vector, vector, vector)
+real wiener_log(row_vector, real[], vector, vector, row_vector)
+real wiener_log(row_vector, real[], vector, vector, real[])
+real wiener_log(row_vector, real[], vector, row_vector, real)
+real wiener_log(row_vector, real[], vector, row_vector, vector)
+real wiener_log(row_vector, real[], vector, row_vector, row_vector)
+real wiener_log(row_vector, real[], vector, row_vector, real[])
+real wiener_log(row_vector, real[], vector, real[], real)
+real wiener_log(row_vector, real[], vector, real[], vector)
+real wiener_log(row_vector, real[], vector, real[], row_vector)
+real wiener_log(row_vector, real[], vector, real[], real[])
+real wiener_log(row_vector, real[], row_vector, real, real)
+real wiener_log(row_vector, real[], row_vector, real, vector)
+real wiener_log(row_vector, real[], row_vector, real, row_vector)
+real wiener_log(row_vector, real[], row_vector, real, real[])
+real wiener_log(row_vector, real[], row_vector, vector, real)
+real wiener_log(row_vector, real[], row_vector, vector, vector)
+real wiener_log(row_vector, real[], row_vector, vector, row_vector)
+real wiener_log(row_vector, real[], row_vector, vector, real[])
+real wiener_log(row_vector, real[], row_vector, row_vector, real)
+real wiener_log(row_vector, real[], row_vector, row_vector, vector)
+real wiener_log(row_vector, real[], row_vector, row_vector, row_vector)
+real wiener_log(row_vector, real[], row_vector, row_vector, real[])
+real wiener_log(row_vector, real[], row_vector, real[], real)
+real wiener_log(row_vector, real[], row_vector, real[], vector)
+real wiener_log(row_vector, real[], row_vector, real[], row_vector)
+real wiener_log(row_vector, real[], row_vector, real[], real[])
+real wiener_log(row_vector, real[], real[], real, real)
+real wiener_log(row_vector, real[], real[], real, vector)
+real wiener_log(row_vector, real[], real[], real, row_vector)
+real wiener_log(row_vector, real[], real[], real, real[])
+real wiener_log(row_vector, real[], real[], vector, real)
+real wiener_log(row_vector, real[], real[], vector, vector)
+real wiener_log(row_vector, real[], real[], vector, row_vector)
+real wiener_log(row_vector, real[], real[], vector, real[])
+real wiener_log(row_vector, real[], real[], row_vector, real)
+real wiener_log(row_vector, real[], real[], row_vector, vector)
+real wiener_log(row_vector, real[], real[], row_vector, row_vector)
+real wiener_log(row_vector, real[], real[], row_vector, real[])
+real wiener_log(row_vector, real[], real[], real[], real)
+real wiener_log(row_vector, real[], real[], real[], vector)
+real wiener_log(row_vector, real[], real[], real[], row_vector)
+real wiener_log(row_vector, real[], real[], real[], real[])
+real wiener_log(real[], real, real, real, vector)
+real wiener_log(real[], real, real, real, row_vector)
+real wiener_log(real[], real, real, vector, real)
+real wiener_log(real[], real, real, vector, vector)
+real wiener_log(real[], real, real, vector, row_vector)
+real wiener_log(real[], real, real, vector, real[])
+real wiener_log(real[], real, real, row_vector, real)
+real wiener_log(real[], real, real, row_vector, vector)
+real wiener_log(real[], real, real, row_vector, row_vector)
+real wiener_log(real[], real, real, row_vector, real[])
+real wiener_log(real[], real, real, real[], vector)
+real wiener_log(real[], real, real, real[], row_vector)
+real wiener_log(real[], real, vector, real, real)
+real wiener_log(real[], real, vector, real, vector)
+real wiener_log(real[], real, vector, real, row_vector)
+real wiener_log(real[], real, vector, real, real[])
+real wiener_log(real[], real, vector, vector, real)
+real wiener_log(real[], real, vector, vector, vector)
+real wiener_log(real[], real, vector, vector, row_vector)
+real wiener_log(real[], real, vector, vector, real[])
+real wiener_log(real[], real, vector, row_vector, real)
+real wiener_log(real[], real, vector, row_vector, vector)
+real wiener_log(real[], real, vector, row_vector, row_vector)
+real wiener_log(real[], real, vector, row_vector, real[])
+real wiener_log(real[], real, vector, real[], real)
+real wiener_log(real[], real, vector, real[], vector)
+real wiener_log(real[], real, vector, real[], row_vector)
+real wiener_log(real[], real, vector, real[], real[])
+real wiener_log(real[], real, row_vector, real, real)
+real wiener_log(real[], real, row_vector, real, vector)
+real wiener_log(real[], real, row_vector, real, row_vector)
+real wiener_log(real[], real, row_vector, real, real[])
+real wiener_log(real[], real, row_vector, vector, real)
+real wiener_log(real[], real, row_vector, vector, vector)
+real wiener_log(real[], real, row_vector, vector, row_vector)
+real wiener_log(real[], real, row_vector, vector, real[])
+real wiener_log(real[], real, row_vector, row_vector, real)
+real wiener_log(real[], real, row_vector, row_vector, vector)
+real wiener_log(real[], real, row_vector, row_vector, row_vector)
+real wiener_log(real[], real, row_vector, row_vector, real[])
+real wiener_log(real[], real, row_vector, real[], real)
+real wiener_log(real[], real, row_vector, real[], vector)
+real wiener_log(real[], real, row_vector, real[], row_vector)
+real wiener_log(real[], real, row_vector, real[], real[])
+real wiener_log(real[], real, real[], real, vector)
+real wiener_log(real[], real, real[], real, row_vector)
+real wiener_log(real[], real, real[], vector, real)
+real wiener_log(real[], real, real[], vector, vector)
+real wiener_log(real[], real, real[], vector, row_vector)
+real wiener_log(real[], real, real[], vector, real[])
+real wiener_log(real[], real, real[], row_vector, real)
+real wiener_log(real[], real, real[], row_vector, vector)
+real wiener_log(real[], real, real[], row_vector, row_vector)
+real wiener_log(real[], real, real[], row_vector, real[])
+real wiener_log(real[], real, real[], real[], vector)
+real wiener_log(real[], real, real[], real[], row_vector)
+real wiener_log(real[], vector, real, real, real)
+real wiener_log(real[], vector, real, real, vector)
+real wiener_log(real[], vector, real, real, row_vector)
+real wiener_log(real[], vector, real, real, real[])
+real wiener_log(real[], vector, real, vector, real)
+real wiener_log(real[], vector, real, vector, vector)
+real wiener_log(real[], vector, real, vector, row_vector)
+real wiener_log(real[], vector, real, vector, real[])
+real wiener_log(real[], vector, real, row_vector, real)
+real wiener_log(real[], vector, real, row_vector, vector)
+real wiener_log(real[], vector, real, row_vector, row_vector)
+real wiener_log(real[], vector, real, row_vector, real[])
+real wiener_log(real[], vector, real, real[], real)
+real wiener_log(real[], vector, real, real[], vector)
+real wiener_log(real[], vector, real, real[], row_vector)
+real wiener_log(real[], vector, real, real[], real[])
+real wiener_log(real[], vector, vector, real, real)
+real wiener_log(real[], vector, vector, real, vector)
+real wiener_log(real[], vector, vector, real, row_vector)
+real wiener_log(real[], vector, vector, real, real[])
+real wiener_log(real[], vector, vector, vector, real)
+real wiener_log(real[], vector, vector, vector, vector)
+real wiener_log(real[], vector, vector, vector, row_vector)
+real wiener_log(real[], vector, vector, vector, real[])
+real wiener_log(real[], vector, vector, row_vector, real)
+real wiener_log(real[], vector, vector, row_vector, vector)
+real wiener_log(real[], vector, vector, row_vector, row_vector)
+real wiener_log(real[], vector, vector, row_vector, real[])
+real wiener_log(real[], vector, vector, real[], real)
+real wiener_log(real[], vector, vector, real[], vector)
+real wiener_log(real[], vector, vector, real[], row_vector)
+real wiener_log(real[], vector, vector, real[], real[])
+real wiener_log(real[], vector, row_vector, real, real)
+real wiener_log(real[], vector, row_vector, real, vector)
+real wiener_log(real[], vector, row_vector, real, row_vector)
+real wiener_log(real[], vector, row_vector, real, real[])
+real wiener_log(real[], vector, row_vector, vector, real)
+real wiener_log(real[], vector, row_vector, vector, vector)
+real wiener_log(real[], vector, row_vector, vector, row_vector)
+real wiener_log(real[], vector, row_vector, vector, real[])
+real wiener_log(real[], vector, row_vector, row_vector, real)
+real wiener_log(real[], vector, row_vector, row_vector, vector)
+real wiener_log(real[], vector, row_vector, row_vector, row_vector)
+real wiener_log(real[], vector, row_vector, row_vector, real[])
+real wiener_log(real[], vector, row_vector, real[], real)
+real wiener_log(real[], vector, row_vector, real[], vector)
+real wiener_log(real[], vector, row_vector, real[], row_vector)
+real wiener_log(real[], vector, row_vector, real[], real[])
+real wiener_log(real[], vector, real[], real, real)
+real wiener_log(real[], vector, real[], real, vector)
+real wiener_log(real[], vector, real[], real, row_vector)
+real wiener_log(real[], vector, real[], real, real[])
+real wiener_log(real[], vector, real[], vector, real)
+real wiener_log(real[], vector, real[], vector, vector)
+real wiener_log(real[], vector, real[], vector, row_vector)
+real wiener_log(real[], vector, real[], vector, real[])
+real wiener_log(real[], vector, real[], row_vector, real)
+real wiener_log(real[], vector, real[], row_vector, vector)
+real wiener_log(real[], vector, real[], row_vector, row_vector)
+real wiener_log(real[], vector, real[], row_vector, real[])
+real wiener_log(real[], vector, real[], real[], real)
+real wiener_log(real[], vector, real[], real[], vector)
+real wiener_log(real[], vector, real[], real[], row_vector)
+real wiener_log(real[], vector, real[], real[], real[])
+real wiener_log(real[], row_vector, real, real, real)
+real wiener_log(real[], row_vector, real, real, vector)
+real wiener_log(real[], row_vector, real, real, row_vector)
+real wiener_log(real[], row_vector, real, real, real[])
+real wiener_log(real[], row_vector, real, vector, real)
+real wiener_log(real[], row_vector, real, vector, vector)
+real wiener_log(real[], row_vector, real, vector, row_vector)
+real wiener_log(real[], row_vector, real, vector, real[])
+real wiener_log(real[], row_vector, real, row_vector, real)
+real wiener_log(real[], row_vector, real, row_vector, vector)
+real wiener_log(real[], row_vector, real, row_vector, row_vector)
+real wiener_log(real[], row_vector, real, row_vector, real[])
+real wiener_log(real[], row_vector, real, real[], real)
+real wiener_log(real[], row_vector, real, real[], vector)
+real wiener_log(real[], row_vector, real, real[], row_vector)
+real wiener_log(real[], row_vector, real, real[], real[])
+real wiener_log(real[], row_vector, vector, real, real)
+real wiener_log(real[], row_vector, vector, real, vector)
+real wiener_log(real[], row_vector, vector, real, row_vector)
+real wiener_log(real[], row_vector, vector, real, real[])
+real wiener_log(real[], row_vector, vector, vector, real)
+real wiener_log(real[], row_vector, vector, vector, vector)
+real wiener_log(real[], row_vector, vector, vector, row_vector)
+real wiener_log(real[], row_vector, vector, vector, real[])
+real wiener_log(real[], row_vector, vector, row_vector, real)
+real wiener_log(real[], row_vector, vector, row_vector, vector)
+real wiener_log(real[], row_vector, vector, row_vector, row_vector)
+real wiener_log(real[], row_vector, vector, row_vector, real[])
+real wiener_log(real[], row_vector, vector, real[], real)
+real wiener_log(real[], row_vector, vector, real[], vector)
+real wiener_log(real[], row_vector, vector, real[], row_vector)
+real wiener_log(real[], row_vector, vector, real[], real[])
+real wiener_log(real[], row_vector, row_vector, real, real)
+real wiener_log(real[], row_vector, row_vector, real, vector)
+real wiener_log(real[], row_vector, row_vector, real, row_vector)
+real wiener_log(real[], row_vector, row_vector, real, real[])
+real wiener_log(real[], row_vector, row_vector, vector, real)
+real wiener_log(real[], row_vector, row_vector, vector, vector)
+real wiener_log(real[], row_vector, row_vector, vector, row_vector)
+real wiener_log(real[], row_vector, row_vector, vector, real[])
+real wiener_log(real[], row_vector, row_vector, row_vector, real)
+real wiener_log(real[], row_vector, row_vector, row_vector, vector)
+real wiener_log(real[], row_vector, row_vector, row_vector, row_vector)
+real wiener_log(real[], row_vector, row_vector, row_vector, real[])
+real wiener_log(real[], row_vector, row_vector, real[], real)
+real wiener_log(real[], row_vector, row_vector, real[], vector)
+real wiener_log(real[], row_vector, row_vector, real[], row_vector)
+real wiener_log(real[], row_vector, row_vector, real[], real[])
+real wiener_log(real[], row_vector, real[], real, real)
+real wiener_log(real[], row_vector, real[], real, vector)
+real wiener_log(real[], row_vector, real[], real, row_vector)
+real wiener_log(real[], row_vector, real[], real, real[])
+real wiener_log(real[], row_vector, real[], vector, real)
+real wiener_log(real[], row_vector, real[], vector, vector)
+real wiener_log(real[], row_vector, real[], vector, row_vector)
+real wiener_log(real[], row_vector, real[], vector, real[])
+real wiener_log(real[], row_vector, real[], row_vector, real)
+real wiener_log(real[], row_vector, real[], row_vector, vector)
+real wiener_log(real[], row_vector, real[], row_vector, row_vector)
+real wiener_log(real[], row_vector, real[], row_vector, real[])
+real wiener_log(real[], row_vector, real[], real[], real)
+real wiener_log(real[], row_vector, real[], real[], vector)
+real wiener_log(real[], row_vector, real[], real[], row_vector)
+real wiener_log(real[], row_vector, real[], real[], real[])
+real wiener_log(real[], real[], real, real, vector)
+real wiener_log(real[], real[], real, real, row_vector)
+real wiener_log(real[], real[], real, vector, real)
+real wiener_log(real[], real[], real, vector, vector)
+real wiener_log(real[], real[], real, vector, row_vector)
+real wiener_log(real[], real[], real, vector, real[])
+real wiener_log(real[], real[], real, row_vector, real)
+real wiener_log(real[], real[], real, row_vector, vector)
+real wiener_log(real[], real[], real, row_vector, row_vector)
+real wiener_log(real[], real[], real, row_vector, real[])
+real wiener_log(real[], real[], real, real[], vector)
+real wiener_log(real[], real[], real, real[], row_vector)
+real wiener_log(real[], real[], vector, real, real)
+real wiener_log(real[], real[], vector, real, vector)
+real wiener_log(real[], real[], vector, real, row_vector)
+real wiener_log(real[], real[], vector, real, real[])
+real wiener_log(real[], real[], vector, vector, real)
+real wiener_log(real[], real[], vector, vector, vector)
+real wiener_log(real[], real[], vector, vector, row_vector)
+real wiener_log(real[], real[], vector, vector, real[])
+real wiener_log(real[], real[], vector, row_vector, real)
+real wiener_log(real[], real[], vector, row_vector, vector)
+real wiener_log(real[], real[], vector, row_vector, row_vector)
+real wiener_log(real[], real[], vector, row_vector, real[])
+real wiener_log(real[], real[], vector, real[], real)
+real wiener_log(real[], real[], vector, real[], vector)
+real wiener_log(real[], real[], vector, real[], row_vector)
+real wiener_log(real[], real[], vector, real[], real[])
+real wiener_log(real[], real[], row_vector, real, real)
+real wiener_log(real[], real[], row_vector, real, vector)
+real wiener_log(real[], real[], row_vector, real, row_vector)
+real wiener_log(real[], real[], row_vector, real, real[])
+real wiener_log(real[], real[], row_vector, vector, real)
+real wiener_log(real[], real[], row_vector, vector, vector)
+real wiener_log(real[], real[], row_vector, vector, row_vector)
+real wiener_log(real[], real[], row_vector, vector, real[])
+real wiener_log(real[], real[], row_vector, row_vector, real)
+real wiener_log(real[], real[], row_vector, row_vector, vector)
+real wiener_log(real[], real[], row_vector, row_vector, row_vector)
+real wiener_log(real[], real[], row_vector, row_vector, real[])
+real wiener_log(real[], real[], row_vector, real[], real)
+real wiener_log(real[], real[], row_vector, real[], vector)
+real wiener_log(real[], real[], row_vector, real[], row_vector)
+real wiener_log(real[], real[], row_vector, real[], real[])
+real wiener_log(real[], real[], real[], real, vector)
+real wiener_log(real[], real[], real[], real, row_vector)
+real wiener_log(real[], real[], real[], vector, real)
+real wiener_log(real[], real[], real[], vector, vector)
+real wiener_log(real[], real[], real[], vector, row_vector)
+real wiener_log(real[], real[], real[], vector, real[])
+real wiener_log(real[], real[], real[], row_vector, real)
+real wiener_log(real[], real[], real[], row_vector, vector)
+real wiener_log(real[], real[], real[], row_vector, row_vector)
+real wiener_log(real[], real[], real[], row_vector, real[])
+real wiener_log(real[], real[], real[], real[], vector)
+real wiener_log(real[], real[], real[], real[], row_vector)
+real wiener_lpdf(real, real, real, real, vector)
+real wiener_lpdf(real, real, real, real, row_vector)
+real wiener_lpdf(real, real, real, vector, real)
+real wiener_lpdf(real, real, real, vector, vector)
+real wiener_lpdf(real, real, real, vector, row_vector)
+real wiener_lpdf(real, real, real, vector, real[])
+real wiener_lpdf(real, real, real, row_vector, real)
+real wiener_lpdf(real, real, real, row_vector, vector)
+real wiener_lpdf(real, real, real, row_vector, row_vector)
+real wiener_lpdf(real, real, real, row_vector, real[])
+real wiener_lpdf(real, real, real, real[], vector)
+real wiener_lpdf(real, real, real, real[], row_vector)
+real wiener_lpdf(real, real, vector, real, real)
+real wiener_lpdf(real, real, vector, real, vector)
+real wiener_lpdf(real, real, vector, real, row_vector)
+real wiener_lpdf(real, real, vector, real, real[])
+real wiener_lpdf(real, real, vector, vector, real)
+real wiener_lpdf(real, real, vector, vector, vector)
+real wiener_lpdf(real, real, vector, vector, row_vector)
+real wiener_lpdf(real, real, vector, vector, real[])
+real wiener_lpdf(real, real, vector, row_vector, real)
+real wiener_lpdf(real, real, vector, row_vector, vector)
+real wiener_lpdf(real, real, vector, row_vector, row_vector)
+real wiener_lpdf(real, real, vector, row_vector, real[])
+real wiener_lpdf(real, real, vector, real[], real)
+real wiener_lpdf(real, real, vector, real[], vector)
+real wiener_lpdf(real, real, vector, real[], row_vector)
+real wiener_lpdf(real, real, vector, real[], real[])
+real wiener_lpdf(real, real, row_vector, real, real)
+real wiener_lpdf(real, real, row_vector, real, vector)
+real wiener_lpdf(real, real, row_vector, real, row_vector)
+real wiener_lpdf(real, real, row_vector, real, real[])
+real wiener_lpdf(real, real, row_vector, vector, real)
+real wiener_lpdf(real, real, row_vector, vector, vector)
+real wiener_lpdf(real, real, row_vector, vector, row_vector)
+real wiener_lpdf(real, real, row_vector, vector, real[])
+real wiener_lpdf(real, real, row_vector, row_vector, real)
+real wiener_lpdf(real, real, row_vector, row_vector, vector)
+real wiener_lpdf(real, real, row_vector, row_vector, row_vector)
+real wiener_lpdf(real, real, row_vector, row_vector, real[])
+real wiener_lpdf(real, real, row_vector, real[], real)
+real wiener_lpdf(real, real, row_vector, real[], vector)
+real wiener_lpdf(real, real, row_vector, real[], row_vector)
+real wiener_lpdf(real, real, row_vector, real[], real[])
+real wiener_lpdf(real, real, real[], real, vector)
+real wiener_lpdf(real, real, real[], real, row_vector)
+real wiener_lpdf(real, real, real[], vector, real)
+real wiener_lpdf(real, real, real[], vector, vector)
+real wiener_lpdf(real, real, real[], vector, row_vector)
+real wiener_lpdf(real, real, real[], vector, real[])
+real wiener_lpdf(real, real, real[], row_vector, real)
+real wiener_lpdf(real, real, real[], row_vector, vector)
+real wiener_lpdf(real, real, real[], row_vector, row_vector)
+real wiener_lpdf(real, real, real[], row_vector, real[])
+real wiener_lpdf(real, real, real[], real[], vector)
+real wiener_lpdf(real, real, real[], real[], row_vector)
+real wiener_lpdf(real, vector, real, real, real)
+real wiener_lpdf(real, vector, real, real, vector)
+real wiener_lpdf(real, vector, real, real, row_vector)
+real wiener_lpdf(real, vector, real, real, real[])
+real wiener_lpdf(real, vector, real, vector, real)
+real wiener_lpdf(real, vector, real, vector, vector)
+real wiener_lpdf(real, vector, real, vector, row_vector)
+real wiener_lpdf(real, vector, real, vector, real[])
+real wiener_lpdf(real, vector, real, row_vector, real)
+real wiener_lpdf(real, vector, real, row_vector, vector)
+real wiener_lpdf(real, vector, real, row_vector, row_vector)
+real wiener_lpdf(real, vector, real, row_vector, real[])
+real wiener_lpdf(real, vector, real, real[], real)
+real wiener_lpdf(real, vector, real, real[], vector)
+real wiener_lpdf(real, vector, real, real[], row_vector)
+real wiener_lpdf(real, vector, real, real[], real[])
+real wiener_lpdf(real, vector, vector, real, real)
+real wiener_lpdf(real, vector, vector, real, vector)
+real wiener_lpdf(real, vector, vector, real, row_vector)
+real wiener_lpdf(real, vector, vector, real, real[])
+real wiener_lpdf(real, vector, vector, vector, real)
+real wiener_lpdf(real, vector, vector, vector, vector)
+real wiener_lpdf(real, vector, vector, vector, row_vector)
+real wiener_lpdf(real, vector, vector, vector, real[])
+real wiener_lpdf(real, vector, vector, row_vector, real)
+real wiener_lpdf(real, vector, vector, row_vector, vector)
+real wiener_lpdf(real, vector, vector, row_vector, row_vector)
+real wiener_lpdf(real, vector, vector, row_vector, real[])
+real wiener_lpdf(real, vector, vector, real[], real)
+real wiener_lpdf(real, vector, vector, real[], vector)
+real wiener_lpdf(real, vector, vector, real[], row_vector)
+real wiener_lpdf(real, vector, vector, real[], real[])
+real wiener_lpdf(real, vector, row_vector, real, real)
+real wiener_lpdf(real, vector, row_vector, real, vector)
+real wiener_lpdf(real, vector, row_vector, real, row_vector)
+real wiener_lpdf(real, vector, row_vector, real, real[])
+real wiener_lpdf(real, vector, row_vector, vector, real)
+real wiener_lpdf(real, vector, row_vector, vector, vector)
+real wiener_lpdf(real, vector, row_vector, vector, row_vector)
+real wiener_lpdf(real, vector, row_vector, vector, real[])
+real wiener_lpdf(real, vector, row_vector, row_vector, real)
+real wiener_lpdf(real, vector, row_vector, row_vector, vector)
+real wiener_lpdf(real, vector, row_vector, row_vector, row_vector)
+real wiener_lpdf(real, vector, row_vector, row_vector, real[])
+real wiener_lpdf(real, vector, row_vector, real[], real)
+real wiener_lpdf(real, vector, row_vector, real[], vector)
+real wiener_lpdf(real, vector, row_vector, real[], row_vector)
+real wiener_lpdf(real, vector, row_vector, real[], real[])
+real wiener_lpdf(real, vector, real[], real, real)
+real wiener_lpdf(real, vector, real[], real, vector)
+real wiener_lpdf(real, vector, real[], real, row_vector)
+real wiener_lpdf(real, vector, real[], real, real[])
+real wiener_lpdf(real, vector, real[], vector, real)
+real wiener_lpdf(real, vector, real[], vector, vector)
+real wiener_lpdf(real, vector, real[], vector, row_vector)
+real wiener_lpdf(real, vector, real[], vector, real[])
+real wiener_lpdf(real, vector, real[], row_vector, real)
+real wiener_lpdf(real, vector, real[], row_vector, vector)
+real wiener_lpdf(real, vector, real[], row_vector, row_vector)
+real wiener_lpdf(real, vector, real[], row_vector, real[])
+real wiener_lpdf(real, vector, real[], real[], real)
+real wiener_lpdf(real, vector, real[], real[], vector)
+real wiener_lpdf(real, vector, real[], real[], row_vector)
+real wiener_lpdf(real, vector, real[], real[], real[])
+real wiener_lpdf(real, row_vector, real, real, real)
+real wiener_lpdf(real, row_vector, real, real, vector)
+real wiener_lpdf(real, row_vector, real, real, row_vector)
+real wiener_lpdf(real, row_vector, real, real, real[])
+real wiener_lpdf(real, row_vector, real, vector, real)
+real wiener_lpdf(real, row_vector, real, vector, vector)
+real wiener_lpdf(real, row_vector, real, vector, row_vector)
+real wiener_lpdf(real, row_vector, real, vector, real[])
+real wiener_lpdf(real, row_vector, real, row_vector, real)
+real wiener_lpdf(real, row_vector, real, row_vector, vector)
+real wiener_lpdf(real, row_vector, real, row_vector, row_vector)
+real wiener_lpdf(real, row_vector, real, row_vector, real[])
+real wiener_lpdf(real, row_vector, real, real[], real)
+real wiener_lpdf(real, row_vector, real, real[], vector)
+real wiener_lpdf(real, row_vector, real, real[], row_vector)
+real wiener_lpdf(real, row_vector, real, real[], real[])
+real wiener_lpdf(real, row_vector, vector, real, real)
+real wiener_lpdf(real, row_vector, vector, real, vector)
+real wiener_lpdf(real, row_vector, vector, real, row_vector)
+real wiener_lpdf(real, row_vector, vector, real, real[])
+real wiener_lpdf(real, row_vector, vector, vector, real)
+real wiener_lpdf(real, row_vector, vector, vector, vector)
+real wiener_lpdf(real, row_vector, vector, vector, row_vector)
+real wiener_lpdf(real, row_vector, vector, vector, real[])
+real wiener_lpdf(real, row_vector, vector, row_vector, real)
+real wiener_lpdf(real, row_vector, vector, row_vector, vector)
+real wiener_lpdf(real, row_vector, vector, row_vector, row_vector)
+real wiener_lpdf(real, row_vector, vector, row_vector, real[])
+real wiener_lpdf(real, row_vector, vector, real[], real)
+real wiener_lpdf(real, row_vector, vector, real[], vector)
+real wiener_lpdf(real, row_vector, vector, real[], row_vector)
+real wiener_lpdf(real, row_vector, vector, real[], real[])
+real wiener_lpdf(real, row_vector, row_vector, real, real)
+real wiener_lpdf(real, row_vector, row_vector, real, vector)
+real wiener_lpdf(real, row_vector, row_vector, real, row_vector)
+real wiener_lpdf(real, row_vector, row_vector, real, real[])
+real wiener_lpdf(real, row_vector, row_vector, vector, real)
+real wiener_lpdf(real, row_vector, row_vector, vector, vector)
+real wiener_lpdf(real, row_vector, row_vector, vector, row_vector)
+real wiener_lpdf(real, row_vector, row_vector, vector, real[])
+real wiener_lpdf(real, row_vector, row_vector, row_vector, real)
+real wiener_lpdf(real, row_vector, row_vector, row_vector, vector)
+real wiener_lpdf(real, row_vector, row_vector, row_vector, row_vector)
+real wiener_lpdf(real, row_vector, row_vector, row_vector, real[])
+real wiener_lpdf(real, row_vector, row_vector, real[], real)
+real wiener_lpdf(real, row_vector, row_vector, real[], vector)
+real wiener_lpdf(real, row_vector, row_vector, real[], row_vector)
+real wiener_lpdf(real, row_vector, row_vector, real[], real[])
+real wiener_lpdf(real, row_vector, real[], real, real)
+real wiener_lpdf(real, row_vector, real[], real, vector)
+real wiener_lpdf(real, row_vector, real[], real, row_vector)
+real wiener_lpdf(real, row_vector, real[], real, real[])
+real wiener_lpdf(real, row_vector, real[], vector, real)
+real wiener_lpdf(real, row_vector, real[], vector, vector)
+real wiener_lpdf(real, row_vector, real[], vector, row_vector)
+real wiener_lpdf(real, row_vector, real[], vector, real[])
+real wiener_lpdf(real, row_vector, real[], row_vector, real)
+real wiener_lpdf(real, row_vector, real[], row_vector, vector)
+real wiener_lpdf(real, row_vector, real[], row_vector, row_vector)
+real wiener_lpdf(real, row_vector, real[], row_vector, real[])
+real wiener_lpdf(real, row_vector, real[], real[], real)
+real wiener_lpdf(real, row_vector, real[], real[], vector)
+real wiener_lpdf(real, row_vector, real[], real[], row_vector)
+real wiener_lpdf(real, row_vector, real[], real[], real[])
+real wiener_lpdf(real, real[], real, real, vector)
+real wiener_lpdf(real, real[], real, real, row_vector)
+real wiener_lpdf(real, real[], real, vector, real)
+real wiener_lpdf(real, real[], real, vector, vector)
+real wiener_lpdf(real, real[], real, vector, row_vector)
+real wiener_lpdf(real, real[], real, vector, real[])
+real wiener_lpdf(real, real[], real, row_vector, real)
+real wiener_lpdf(real, real[], real, row_vector, vector)
+real wiener_lpdf(real, real[], real, row_vector, row_vector)
+real wiener_lpdf(real, real[], real, row_vector, real[])
+real wiener_lpdf(real, real[], real, real[], vector)
+real wiener_lpdf(real, real[], real, real[], row_vector)
+real wiener_lpdf(real, real[], vector, real, real)
+real wiener_lpdf(real, real[], vector, real, vector)
+real wiener_lpdf(real, real[], vector, real, row_vector)
+real wiener_lpdf(real, real[], vector, real, real[])
+real wiener_lpdf(real, real[], vector, vector, real)
+real wiener_lpdf(real, real[], vector, vector, vector)
+real wiener_lpdf(real, real[], vector, vector, row_vector)
+real wiener_lpdf(real, real[], vector, vector, real[])
+real wiener_lpdf(real, real[], vector, row_vector, real)
+real wiener_lpdf(real, real[], vector, row_vector, vector)
+real wiener_lpdf(real, real[], vector, row_vector, row_vector)
+real wiener_lpdf(real, real[], vector, row_vector, real[])
+real wiener_lpdf(real, real[], vector, real[], real)
+real wiener_lpdf(real, real[], vector, real[], vector)
+real wiener_lpdf(real, real[], vector, real[], row_vector)
+real wiener_lpdf(real, real[], vector, real[], real[])
+real wiener_lpdf(real, real[], row_vector, real, real)
+real wiener_lpdf(real, real[], row_vector, real, vector)
+real wiener_lpdf(real, real[], row_vector, real, row_vector)
+real wiener_lpdf(real, real[], row_vector, real, real[])
+real wiener_lpdf(real, real[], row_vector, vector, real)
+real wiener_lpdf(real, real[], row_vector, vector, vector)
+real wiener_lpdf(real, real[], row_vector, vector, row_vector)
+real wiener_lpdf(real, real[], row_vector, vector, real[])
+real wiener_lpdf(real, real[], row_vector, row_vector, real)
+real wiener_lpdf(real, real[], row_vector, row_vector, vector)
+real wiener_lpdf(real, real[], row_vector, row_vector, row_vector)
+real wiener_lpdf(real, real[], row_vector, row_vector, real[])
+real wiener_lpdf(real, real[], row_vector, real[], real)
+real wiener_lpdf(real, real[], row_vector, real[], vector)
+real wiener_lpdf(real, real[], row_vector, real[], row_vector)
+real wiener_lpdf(real, real[], row_vector, real[], real[])
+real wiener_lpdf(real, real[], real[], real, vector)
+real wiener_lpdf(real, real[], real[], real, row_vector)
+real wiener_lpdf(real, real[], real[], vector, real)
+real wiener_lpdf(real, real[], real[], vector, vector)
+real wiener_lpdf(real, real[], real[], vector, row_vector)
+real wiener_lpdf(real, real[], real[], vector, real[])
+real wiener_lpdf(real, real[], real[], row_vector, real)
+real wiener_lpdf(real, real[], real[], row_vector, vector)
+real wiener_lpdf(real, real[], real[], row_vector, row_vector)
+real wiener_lpdf(real, real[], real[], row_vector, real[])
+real wiener_lpdf(real, real[], real[], real[], vector)
+real wiener_lpdf(real, real[], real[], real[], row_vector)
+real wiener_lpdf(vector, real, real, real, real)
+real wiener_lpdf(vector, real, real, real, vector)
+real wiener_lpdf(vector, real, real, real, row_vector)
+real wiener_lpdf(vector, real, real, real, real[])
+real wiener_lpdf(vector, real, real, vector, real)
+real wiener_lpdf(vector, real, real, vector, vector)
+real wiener_lpdf(vector, real, real, vector, row_vector)
+real wiener_lpdf(vector, real, real, vector, real[])
+real wiener_lpdf(vector, real, real, row_vector, real)
+real wiener_lpdf(vector, real, real, row_vector, vector)
+real wiener_lpdf(vector, real, real, row_vector, row_vector)
+real wiener_lpdf(vector, real, real, row_vector, real[])
+real wiener_lpdf(vector, real, real, real[], real)
+real wiener_lpdf(vector, real, real, real[], vector)
+real wiener_lpdf(vector, real, real, real[], row_vector)
+real wiener_lpdf(vector, real, real, real[], real[])
+real wiener_lpdf(vector, real, vector, real, real)
+real wiener_lpdf(vector, real, vector, real, vector)
+real wiener_lpdf(vector, real, vector, real, row_vector)
+real wiener_lpdf(vector, real, vector, real, real[])
+real wiener_lpdf(vector, real, vector, vector, real)
+real wiener_lpdf(vector, real, vector, vector, vector)
+real wiener_lpdf(vector, real, vector, vector, row_vector)
+real wiener_lpdf(vector, real, vector, vector, real[])
+real wiener_lpdf(vector, real, vector, row_vector, real)
+real wiener_lpdf(vector, real, vector, row_vector, vector)
+real wiener_lpdf(vector, real, vector, row_vector, row_vector)
+real wiener_lpdf(vector, real, vector, row_vector, real[])
+real wiener_lpdf(vector, real, vector, real[], real)
+real wiener_lpdf(vector, real, vector, real[], vector)
+real wiener_lpdf(vector, real, vector, real[], row_vector)
+real wiener_lpdf(vector, real, vector, real[], real[])
+real wiener_lpdf(vector, real, row_vector, real, real)
+real wiener_lpdf(vector, real, row_vector, real, vector)
+real wiener_lpdf(vector, real, row_vector, real, row_vector)
+real wiener_lpdf(vector, real, row_vector, real, real[])
+real wiener_lpdf(vector, real, row_vector, vector, real)
+real wiener_lpdf(vector, real, row_vector, vector, vector)
+real wiener_lpdf(vector, real, row_vector, vector, row_vector)
+real wiener_lpdf(vector, real, row_vector, vector, real[])
+real wiener_lpdf(vector, real, row_vector, row_vector, real)
+real wiener_lpdf(vector, real, row_vector, row_vector, vector)
+real wiener_lpdf(vector, real, row_vector, row_vector, row_vector)
+real wiener_lpdf(vector, real, row_vector, row_vector, real[])
+real wiener_lpdf(vector, real, row_vector, real[], real)
+real wiener_lpdf(vector, real, row_vector, real[], vector)
+real wiener_lpdf(vector, real, row_vector, real[], row_vector)
+real wiener_lpdf(vector, real, row_vector, real[], real[])
+real wiener_lpdf(vector, real, real[], real, real)
+real wiener_lpdf(vector, real, real[], real, vector)
+real wiener_lpdf(vector, real, real[], real, row_vector)
+real wiener_lpdf(vector, real, real[], real, real[])
+real wiener_lpdf(vector, real, real[], vector, real)
+real wiener_lpdf(vector, real, real[], vector, vector)
+real wiener_lpdf(vector, real, real[], vector, row_vector)
+real wiener_lpdf(vector, real, real[], vector, real[])
+real wiener_lpdf(vector, real, real[], row_vector, real)
+real wiener_lpdf(vector, real, real[], row_vector, vector)
+real wiener_lpdf(vector, real, real[], row_vector, row_vector)
+real wiener_lpdf(vector, real, real[], row_vector, real[])
+real wiener_lpdf(vector, real, real[], real[], real)
+real wiener_lpdf(vector, real, real[], real[], vector)
+real wiener_lpdf(vector, real, real[], real[], row_vector)
+real wiener_lpdf(vector, real, real[], real[], real[])
+real wiener_lpdf(vector, vector, real, real, real)
+real wiener_lpdf(vector, vector, real, real, vector)
+real wiener_lpdf(vector, vector, real, real, row_vector)
+real wiener_lpdf(vector, vector, real, real, real[])
+real wiener_lpdf(vector, vector, real, vector, real)
+real wiener_lpdf(vector, vector, real, vector, vector)
+real wiener_lpdf(vector, vector, real, vector, row_vector)
+real wiener_lpdf(vector, vector, real, vector, real[])
+real wiener_lpdf(vector, vector, real, row_vector, real)
+real wiener_lpdf(vector, vector, real, row_vector, vector)
+real wiener_lpdf(vector, vector, real, row_vector, row_vector)
+real wiener_lpdf(vector, vector, real, row_vector, real[])
+real wiener_lpdf(vector, vector, real, real[], real)
+real wiener_lpdf(vector, vector, real, real[], vector)
+real wiener_lpdf(vector, vector, real, real[], row_vector)
+real wiener_lpdf(vector, vector, real, real[], real[])
+real wiener_lpdf(vector, vector, vector, real, real)
+real wiener_lpdf(vector, vector, vector, real, vector)
+real wiener_lpdf(vector, vector, vector, real, row_vector)
+real wiener_lpdf(vector, vector, vector, real, real[])
+real wiener_lpdf(vector, vector, vector, vector, real)
+real wiener_lpdf(vector, vector, vector, vector, vector)
+real wiener_lpdf(vector, vector, vector, vector, row_vector)
+real wiener_lpdf(vector, vector, vector, vector, real[])
+real wiener_lpdf(vector, vector, vector, row_vector, real)
+real wiener_lpdf(vector, vector, vector, row_vector, vector)
+real wiener_lpdf(vector, vector, vector, row_vector, row_vector)
+real wiener_lpdf(vector, vector, vector, row_vector, real[])
+real wiener_lpdf(vector, vector, vector, real[], real)
+real wiener_lpdf(vector, vector, vector, real[], vector)
+real wiener_lpdf(vector, vector, vector, real[], row_vector)
+real wiener_lpdf(vector, vector, vector, real[], real[])
+real wiener_lpdf(vector, vector, row_vector, real, real)
+real wiener_lpdf(vector, vector, row_vector, real, vector)
+real wiener_lpdf(vector, vector, row_vector, real, row_vector)
+real wiener_lpdf(vector, vector, row_vector, real, real[])
+real wiener_lpdf(vector, vector, row_vector, vector, real)
+real wiener_lpdf(vector, vector, row_vector, vector, vector)
+real wiener_lpdf(vector, vector, row_vector, vector, row_vector)
+real wiener_lpdf(vector, vector, row_vector, vector, real[])
+real wiener_lpdf(vector, vector, row_vector, row_vector, real)
+real wiener_lpdf(vector, vector, row_vector, row_vector, vector)
+real wiener_lpdf(vector, vector, row_vector, row_vector, row_vector)
+real wiener_lpdf(vector, vector, row_vector, row_vector, real[])
+real wiener_lpdf(vector, vector, row_vector, real[], real)
+real wiener_lpdf(vector, vector, row_vector, real[], vector)
+real wiener_lpdf(vector, vector, row_vector, real[], row_vector)
+real wiener_lpdf(vector, vector, row_vector, real[], real[])
+real wiener_lpdf(vector, vector, real[], real, real)
+real wiener_lpdf(vector, vector, real[], real, vector)
+real wiener_lpdf(vector, vector, real[], real, row_vector)
+real wiener_lpdf(vector, vector, real[], real, real[])
+real wiener_lpdf(vector, vector, real[], vector, real)
+real wiener_lpdf(vector, vector, real[], vector, vector)
+real wiener_lpdf(vector, vector, real[], vector, row_vector)
+real wiener_lpdf(vector, vector, real[], vector, real[])
+real wiener_lpdf(vector, vector, real[], row_vector, real)
+real wiener_lpdf(vector, vector, real[], row_vector, vector)
+real wiener_lpdf(vector, vector, real[], row_vector, row_vector)
+real wiener_lpdf(vector, vector, real[], row_vector, real[])
+real wiener_lpdf(vector, vector, real[], real[], real)
+real wiener_lpdf(vector, vector, real[], real[], vector)
+real wiener_lpdf(vector, vector, real[], real[], row_vector)
+real wiener_lpdf(vector, vector, real[], real[], real[])
+real wiener_lpdf(vector, row_vector, real, real, real)
+real wiener_lpdf(vector, row_vector, real, real, vector)
+real wiener_lpdf(vector, row_vector, real, real, row_vector)
+real wiener_lpdf(vector, row_vector, real, real, real[])
+real wiener_lpdf(vector, row_vector, real, vector, real)
+real wiener_lpdf(vector, row_vector, real, vector, vector)
+real wiener_lpdf(vector, row_vector, real, vector, row_vector)
+real wiener_lpdf(vector, row_vector, real, vector, real[])
+real wiener_lpdf(vector, row_vector, real, row_vector, real)
+real wiener_lpdf(vector, row_vector, real, row_vector, vector)
+real wiener_lpdf(vector, row_vector, real, row_vector, row_vector)
+real wiener_lpdf(vector, row_vector, real, row_vector, real[])
+real wiener_lpdf(vector, row_vector, real, real[], real)
+real wiener_lpdf(vector, row_vector, real, real[], vector)
+real wiener_lpdf(vector, row_vector, real, real[], row_vector)
+real wiener_lpdf(vector, row_vector, real, real[], real[])
+real wiener_lpdf(vector, row_vector, vector, real, real)
+real wiener_lpdf(vector, row_vector, vector, real, vector)
+real wiener_lpdf(vector, row_vector, vector, real, row_vector)
+real wiener_lpdf(vector, row_vector, vector, real, real[])
+real wiener_lpdf(vector, row_vector, vector, vector, real)
+real wiener_lpdf(vector, row_vector, vector, vector, vector)
+real wiener_lpdf(vector, row_vector, vector, vector, row_vector)
+real wiener_lpdf(vector, row_vector, vector, vector, real[])
+real wiener_lpdf(vector, row_vector, vector, row_vector, real)
+real wiener_lpdf(vector, row_vector, vector, row_vector, vector)
+real wiener_lpdf(vector, row_vector, vector, row_vector, row_vector)
+real wiener_lpdf(vector, row_vector, vector, row_vector, real[])
+real wiener_lpdf(vector, row_vector, vector, real[], real)
+real wiener_lpdf(vector, row_vector, vector, real[], vector)
+real wiener_lpdf(vector, row_vector, vector, real[], row_vector)
+real wiener_lpdf(vector, row_vector, vector, real[], real[])
+real wiener_lpdf(vector, row_vector, row_vector, real, real)
+real wiener_lpdf(vector, row_vector, row_vector, real, vector)
+real wiener_lpdf(vector, row_vector, row_vector, real, row_vector)
+real wiener_lpdf(vector, row_vector, row_vector, real, real[])
+real wiener_lpdf(vector, row_vector, row_vector, vector, real)
+real wiener_lpdf(vector, row_vector, row_vector, vector, vector)
+real wiener_lpdf(vector, row_vector, row_vector, vector, row_vector)
+real wiener_lpdf(vector, row_vector, row_vector, vector, real[])
+real wiener_lpdf(vector, row_vector, row_vector, row_vector, real)
+real wiener_lpdf(vector, row_vector, row_vector, row_vector, vector)
+real wiener_lpdf(vector, row_vector, row_vector, row_vector, row_vector)
+real wiener_lpdf(vector, row_vector, row_vector, row_vector, real[])
+real wiener_lpdf(vector, row_vector, row_vector, real[], real)
+real wiener_lpdf(vector, row_vector, row_vector, real[], vector)
+real wiener_lpdf(vector, row_vector, row_vector, real[], row_vector)
+real wiener_lpdf(vector, row_vector, row_vector, real[], real[])
+real wiener_lpdf(vector, row_vector, real[], real, real)
+real wiener_lpdf(vector, row_vector, real[], real, vector)
+real wiener_lpdf(vector, row_vector, real[], real, row_vector)
+real wiener_lpdf(vector, row_vector, real[], real, real[])
+real wiener_lpdf(vector, row_vector, real[], vector, real)
+real wiener_lpdf(vector, row_vector, real[], vector, vector)
+real wiener_lpdf(vector, row_vector, real[], vector, row_vector)
+real wiener_lpdf(vector, row_vector, real[], vector, real[])
+real wiener_lpdf(vector, row_vector, real[], row_vector, real)
+real wiener_lpdf(vector, row_vector, real[], row_vector, vector)
+real wiener_lpdf(vector, row_vector, real[], row_vector, row_vector)
+real wiener_lpdf(vector, row_vector, real[], row_vector, real[])
+real wiener_lpdf(vector, row_vector, real[], real[], real)
+real wiener_lpdf(vector, row_vector, real[], real[], vector)
+real wiener_lpdf(vector, row_vector, real[], real[], row_vector)
+real wiener_lpdf(vector, row_vector, real[], real[], real[])
+real wiener_lpdf(vector, real[], real, real, real)
+real wiener_lpdf(vector, real[], real, real, vector)
+real wiener_lpdf(vector, real[], real, real, row_vector)
+real wiener_lpdf(vector, real[], real, real, real[])
+real wiener_lpdf(vector, real[], real, vector, real)
+real wiener_lpdf(vector, real[], real, vector, vector)
+real wiener_lpdf(vector, real[], real, vector, row_vector)
+real wiener_lpdf(vector, real[], real, vector, real[])
+real wiener_lpdf(vector, real[], real, row_vector, real)
+real wiener_lpdf(vector, real[], real, row_vector, vector)
+real wiener_lpdf(vector, real[], real, row_vector, row_vector)
+real wiener_lpdf(vector, real[], real, row_vector, real[])
+real wiener_lpdf(vector, real[], real, real[], real)
+real wiener_lpdf(vector, real[], real, real[], vector)
+real wiener_lpdf(vector, real[], real, real[], row_vector)
+real wiener_lpdf(vector, real[], real, real[], real[])
+real wiener_lpdf(vector, real[], vector, real, real)
+real wiener_lpdf(vector, real[], vector, real, vector)
+real wiener_lpdf(vector, real[], vector, real, row_vector)
+real wiener_lpdf(vector, real[], vector, real, real[])
+real wiener_lpdf(vector, real[], vector, vector, real)
+real wiener_lpdf(vector, real[], vector, vector, vector)
+real wiener_lpdf(vector, real[], vector, vector, row_vector)
+real wiener_lpdf(vector, real[], vector, vector, real[])
+real wiener_lpdf(vector, real[], vector, row_vector, real)
+real wiener_lpdf(vector, real[], vector, row_vector, vector)
+real wiener_lpdf(vector, real[], vector, row_vector, row_vector)
+real wiener_lpdf(vector, real[], vector, row_vector, real[])
+real wiener_lpdf(vector, real[], vector, real[], real)
+real wiener_lpdf(vector, real[], vector, real[], vector)
+real wiener_lpdf(vector, real[], vector, real[], row_vector)
+real wiener_lpdf(vector, real[], vector, real[], real[])
+real wiener_lpdf(vector, real[], row_vector, real, real)
+real wiener_lpdf(vector, real[], row_vector, real, vector)
+real wiener_lpdf(vector, real[], row_vector, real, row_vector)
+real wiener_lpdf(vector, real[], row_vector, real, real[])
+real wiener_lpdf(vector, real[], row_vector, vector, real)
+real wiener_lpdf(vector, real[], row_vector, vector, vector)
+real wiener_lpdf(vector, real[], row_vector, vector, row_vector)
+real wiener_lpdf(vector, real[], row_vector, vector, real[])
+real wiener_lpdf(vector, real[], row_vector, row_vector, real)
+real wiener_lpdf(vector, real[], row_vector, row_vector, vector)
+real wiener_lpdf(vector, real[], row_vector, row_vector, row_vector)
+real wiener_lpdf(vector, real[], row_vector, row_vector, real[])
+real wiener_lpdf(vector, real[], row_vector, real[], real)
+real wiener_lpdf(vector, real[], row_vector, real[], vector)
+real wiener_lpdf(vector, real[], row_vector, real[], row_vector)
+real wiener_lpdf(vector, real[], row_vector, real[], real[])
+real wiener_lpdf(vector, real[], real[], real, real)
+real wiener_lpdf(vector, real[], real[], real, vector)
+real wiener_lpdf(vector, real[], real[], real, row_vector)
+real wiener_lpdf(vector, real[], real[], real, real[])
+real wiener_lpdf(vector, real[], real[], vector, real)
+real wiener_lpdf(vector, real[], real[], vector, vector)
+real wiener_lpdf(vector, real[], real[], vector, row_vector)
+real wiener_lpdf(vector, real[], real[], vector, real[])
+real wiener_lpdf(vector, real[], real[], row_vector, real)
+real wiener_lpdf(vector, real[], real[], row_vector, vector)
+real wiener_lpdf(vector, real[], real[], row_vector, row_vector)
+real wiener_lpdf(vector, real[], real[], row_vector, real[])
+real wiener_lpdf(vector, real[], real[], real[], real)
+real wiener_lpdf(vector, real[], real[], real[], vector)
+real wiener_lpdf(vector, real[], real[], real[], row_vector)
+real wiener_lpdf(vector, real[], real[], real[], real[])
+real wiener_lpdf(row_vector, real, real, real, real)
+real wiener_lpdf(row_vector, real, real, real, vector)
+real wiener_lpdf(row_vector, real, real, real, row_vector)
+real wiener_lpdf(row_vector, real, real, real, real[])
+real wiener_lpdf(row_vector, real, real, vector, real)
+real wiener_lpdf(row_vector, real, real, vector, vector)
+real wiener_lpdf(row_vector, real, real, vector, row_vector)
+real wiener_lpdf(row_vector, real, real, vector, real[])
+real wiener_lpdf(row_vector, real, real, row_vector, real)
+real wiener_lpdf(row_vector, real, real, row_vector, vector)
+real wiener_lpdf(row_vector, real, real, row_vector, row_vector)
+real wiener_lpdf(row_vector, real, real, row_vector, real[])
+real wiener_lpdf(row_vector, real, real, real[], real)
+real wiener_lpdf(row_vector, real, real, real[], vector)
+real wiener_lpdf(row_vector, real, real, real[], row_vector)
+real wiener_lpdf(row_vector, real, real, real[], real[])
+real wiener_lpdf(row_vector, real, vector, real, real)
+real wiener_lpdf(row_vector, real, vector, real, vector)
+real wiener_lpdf(row_vector, real, vector, real, row_vector)
+real wiener_lpdf(row_vector, real, vector, real, real[])
+real wiener_lpdf(row_vector, real, vector, vector, real)
+real wiener_lpdf(row_vector, real, vector, vector, vector)
+real wiener_lpdf(row_vector, real, vector, vector, row_vector)
+real wiener_lpdf(row_vector, real, vector, vector, real[])
+real wiener_lpdf(row_vector, real, vector, row_vector, real)
+real wiener_lpdf(row_vector, real, vector, row_vector, vector)
+real wiener_lpdf(row_vector, real, vector, row_vector, row_vector)
+real wiener_lpdf(row_vector, real, vector, row_vector, real[])
+real wiener_lpdf(row_vector, real, vector, real[], real)
+real wiener_lpdf(row_vector, real, vector, real[], vector)
+real wiener_lpdf(row_vector, real, vector, real[], row_vector)
+real wiener_lpdf(row_vector, real, vector, real[], real[])
+real wiener_lpdf(row_vector, real, row_vector, real, real)
+real wiener_lpdf(row_vector, real, row_vector, real, vector)
+real wiener_lpdf(row_vector, real, row_vector, real, row_vector)
+real wiener_lpdf(row_vector, real, row_vector, real, real[])
+real wiener_lpdf(row_vector, real, row_vector, vector, real)
+real wiener_lpdf(row_vector, real, row_vector, vector, vector)
+real wiener_lpdf(row_vector, real, row_vector, vector, row_vector)
+real wiener_lpdf(row_vector, real, row_vector, vector, real[])
+real wiener_lpdf(row_vector, real, row_vector, row_vector, real)
+real wiener_lpdf(row_vector, real, row_vector, row_vector, vector)
+real wiener_lpdf(row_vector, real, row_vector, row_vector, row_vector)
+real wiener_lpdf(row_vector, real, row_vector, row_vector, real[])
+real wiener_lpdf(row_vector, real, row_vector, real[], real)
+real wiener_lpdf(row_vector, real, row_vector, real[], vector)
+real wiener_lpdf(row_vector, real, row_vector, real[], row_vector)
+real wiener_lpdf(row_vector, real, row_vector, real[], real[])
+real wiener_lpdf(row_vector, real, real[], real, real)
+real wiener_lpdf(row_vector, real, real[], real, vector)
+real wiener_lpdf(row_vector, real, real[], real, row_vector)
+real wiener_lpdf(row_vector, real, real[], real, real[])
+real wiener_lpdf(row_vector, real, real[], vector, real)
+real wiener_lpdf(row_vector, real, real[], vector, vector)
+real wiener_lpdf(row_vector, real, real[], vector, row_vector)
+real wiener_lpdf(row_vector, real, real[], vector, real[])
+real wiener_lpdf(row_vector, real, real[], row_vector, real)
+real wiener_lpdf(row_vector, real, real[], row_vector, vector)
+real wiener_lpdf(row_vector, real, real[], row_vector, row_vector)
+real wiener_lpdf(row_vector, real, real[], row_vector, real[])
+real wiener_lpdf(row_vector, real, real[], real[], real)
+real wiener_lpdf(row_vector, real, real[], real[], vector)
+real wiener_lpdf(row_vector, real, real[], real[], row_vector)
+real wiener_lpdf(row_vector, real, real[], real[], real[])
+real wiener_lpdf(row_vector, vector, real, real, real)
+real wiener_lpdf(row_vector, vector, real, real, vector)
+real wiener_lpdf(row_vector, vector, real, real, row_vector)
+real wiener_lpdf(row_vector, vector, real, real, real[])
+real wiener_lpdf(row_vector, vector, real, vector, real)
+real wiener_lpdf(row_vector, vector, real, vector, vector)
+real wiener_lpdf(row_vector, vector, real, vector, row_vector)
+real wiener_lpdf(row_vector, vector, real, vector, real[])
+real wiener_lpdf(row_vector, vector, real, row_vector, real)
+real wiener_lpdf(row_vector, vector, real, row_vector, vector)
+real wiener_lpdf(row_vector, vector, real, row_vector, row_vector)
+real wiener_lpdf(row_vector, vector, real, row_vector, real[])
+real wiener_lpdf(row_vector, vector, real, real[], real)
+real wiener_lpdf(row_vector, vector, real, real[], vector)
+real wiener_lpdf(row_vector, vector, real, real[], row_vector)
+real wiener_lpdf(row_vector, vector, real, real[], real[])
+real wiener_lpdf(row_vector, vector, vector, real, real)
+real wiener_lpdf(row_vector, vector, vector, real, vector)
+real wiener_lpdf(row_vector, vector, vector, real, row_vector)
+real wiener_lpdf(row_vector, vector, vector, real, real[])
+real wiener_lpdf(row_vector, vector, vector, vector, real)
+real wiener_lpdf(row_vector, vector, vector, vector, vector)
+real wiener_lpdf(row_vector, vector, vector, vector, row_vector)
+real wiener_lpdf(row_vector, vector, vector, vector, real[])
+real wiener_lpdf(row_vector, vector, vector, row_vector, real)
+real wiener_lpdf(row_vector, vector, vector, row_vector, vector)
+real wiener_lpdf(row_vector, vector, vector, row_vector, row_vector)
+real wiener_lpdf(row_vector, vector, vector, row_vector, real[])
+real wiener_lpdf(row_vector, vector, vector, real[], real)
+real wiener_lpdf(row_vector, vector, vector, real[], vector)
+real wiener_lpdf(row_vector, vector, vector, real[], row_vector)
+real wiener_lpdf(row_vector, vector, vector, real[], real[])
+real wiener_lpdf(row_vector, vector, row_vector, real, real)
+real wiener_lpdf(row_vector, vector, row_vector, real, vector)
+real wiener_lpdf(row_vector, vector, row_vector, real, row_vector)
+real wiener_lpdf(row_vector, vector, row_vector, real, real[])
+real wiener_lpdf(row_vector, vector, row_vector, vector, real)
+real wiener_lpdf(row_vector, vector, row_vector, vector, vector)
+real wiener_lpdf(row_vector, vector, row_vector, vector, row_vector)
+real wiener_lpdf(row_vector, vector, row_vector, vector, real[])
+real wiener_lpdf(row_vector, vector, row_vector, row_vector, real)
+real wiener_lpdf(row_vector, vector, row_vector, row_vector, vector)
+real wiener_lpdf(row_vector, vector, row_vector, row_vector, row_vector)
+real wiener_lpdf(row_vector, vector, row_vector, row_vector, real[])
+real wiener_lpdf(row_vector, vector, row_vector, real[], real)
+real wiener_lpdf(row_vector, vector, row_vector, real[], vector)
+real wiener_lpdf(row_vector, vector, row_vector, real[], row_vector)
+real wiener_lpdf(row_vector, vector, row_vector, real[], real[])
+real wiener_lpdf(row_vector, vector, real[], real, real)
+real wiener_lpdf(row_vector, vector, real[], real, vector)
+real wiener_lpdf(row_vector, vector, real[], real, row_vector)
+real wiener_lpdf(row_vector, vector, real[], real, real[])
+real wiener_lpdf(row_vector, vector, real[], vector, real)
+real wiener_lpdf(row_vector, vector, real[], vector, vector)
+real wiener_lpdf(row_vector, vector, real[], vector, row_vector)
+real wiener_lpdf(row_vector, vector, real[], vector, real[])
+real wiener_lpdf(row_vector, vector, real[], row_vector, real)
+real wiener_lpdf(row_vector, vector, real[], row_vector, vector)
+real wiener_lpdf(row_vector, vector, real[], row_vector, row_vector)
+real wiener_lpdf(row_vector, vector, real[], row_vector, real[])
+real wiener_lpdf(row_vector, vector, real[], real[], real)
+real wiener_lpdf(row_vector, vector, real[], real[], vector)
+real wiener_lpdf(row_vector, vector, real[], real[], row_vector)
+real wiener_lpdf(row_vector, vector, real[], real[], real[])
+real wiener_lpdf(row_vector, row_vector, real, real, real)
+real wiener_lpdf(row_vector, row_vector, real, real, vector)
+real wiener_lpdf(row_vector, row_vector, real, real, row_vector)
+real wiener_lpdf(row_vector, row_vector, real, real, real[])
+real wiener_lpdf(row_vector, row_vector, real, vector, real)
+real wiener_lpdf(row_vector, row_vector, real, vector, vector)
+real wiener_lpdf(row_vector, row_vector, real, vector, row_vector)
+real wiener_lpdf(row_vector, row_vector, real, vector, real[])
+real wiener_lpdf(row_vector, row_vector, real, row_vector, real)
+real wiener_lpdf(row_vector, row_vector, real, row_vector, vector)
+real wiener_lpdf(row_vector, row_vector, real, row_vector, row_vector)
+real wiener_lpdf(row_vector, row_vector, real, row_vector, real[])
+real wiener_lpdf(row_vector, row_vector, real, real[], real)
+real wiener_lpdf(row_vector, row_vector, real, real[], vector)
+real wiener_lpdf(row_vector, row_vector, real, real[], row_vector)
+real wiener_lpdf(row_vector, row_vector, real, real[], real[])
+real wiener_lpdf(row_vector, row_vector, vector, real, real)
+real wiener_lpdf(row_vector, row_vector, vector, real, vector)
+real wiener_lpdf(row_vector, row_vector, vector, real, row_vector)
+real wiener_lpdf(row_vector, row_vector, vector, real, real[])
+real wiener_lpdf(row_vector, row_vector, vector, vector, real)
+real wiener_lpdf(row_vector, row_vector, vector, vector, vector)
+real wiener_lpdf(row_vector, row_vector, vector, vector, row_vector)
+real wiener_lpdf(row_vector, row_vector, vector, vector, real[])
+real wiener_lpdf(row_vector, row_vector, vector, row_vector, real)
+real wiener_lpdf(row_vector, row_vector, vector, row_vector, vector)
+real wiener_lpdf(row_vector, row_vector, vector, row_vector, row_vector)
+real wiener_lpdf(row_vector, row_vector, vector, row_vector, real[])
+real wiener_lpdf(row_vector, row_vector, vector, real[], real)
+real wiener_lpdf(row_vector, row_vector, vector, real[], vector)
+real wiener_lpdf(row_vector, row_vector, vector, real[], row_vector)
+real wiener_lpdf(row_vector, row_vector, vector, real[], real[])
+real wiener_lpdf(row_vector, row_vector, row_vector, real, real)
+real wiener_lpdf(row_vector, row_vector, row_vector, real, vector)
+real wiener_lpdf(row_vector, row_vector, row_vector, real, row_vector)
+real wiener_lpdf(row_vector, row_vector, row_vector, real, real[])
+real wiener_lpdf(row_vector, row_vector, row_vector, vector, real)
+real wiener_lpdf(row_vector, row_vector, row_vector, vector, vector)
+real wiener_lpdf(row_vector, row_vector, row_vector, vector, row_vector)
+real wiener_lpdf(row_vector, row_vector, row_vector, vector, real[])
+real wiener_lpdf(row_vector, row_vector, row_vector, row_vector, real)
+real wiener_lpdf(row_vector, row_vector, row_vector, row_vector, vector)
+real wiener_lpdf(row_vector, row_vector, row_vector, row_vector, row_vector)
+real wiener_lpdf(row_vector, row_vector, row_vector, row_vector, real[])
+real wiener_lpdf(row_vector, row_vector, row_vector, real[], real)
+real wiener_lpdf(row_vector, row_vector, row_vector, real[], vector)
+real wiener_lpdf(row_vector, row_vector, row_vector, real[], row_vector)
+real wiener_lpdf(row_vector, row_vector, row_vector, real[], real[])
+real wiener_lpdf(row_vector, row_vector, real[], real, real)
+real wiener_lpdf(row_vector, row_vector, real[], real, vector)
+real wiener_lpdf(row_vector, row_vector, real[], real, row_vector)
+real wiener_lpdf(row_vector, row_vector, real[], real, real[])
+real wiener_lpdf(row_vector, row_vector, real[], vector, real)
+real wiener_lpdf(row_vector, row_vector, real[], vector, vector)
+real wiener_lpdf(row_vector, row_vector, real[], vector, row_vector)
+real wiener_lpdf(row_vector, row_vector, real[], vector, real[])
+real wiener_lpdf(row_vector, row_vector, real[], row_vector, real)
+real wiener_lpdf(row_vector, row_vector, real[], row_vector, vector)
+real wiener_lpdf(row_vector, row_vector, real[], row_vector, row_vector)
+real wiener_lpdf(row_vector, row_vector, real[], row_vector, real[])
+real wiener_lpdf(row_vector, row_vector, real[], real[], real)
+real wiener_lpdf(row_vector, row_vector, real[], real[], vector)
+real wiener_lpdf(row_vector, row_vector, real[], real[], row_vector)
+real wiener_lpdf(row_vector, row_vector, real[], real[], real[])
+real wiener_lpdf(row_vector, real[], real, real, real)
+real wiener_lpdf(row_vector, real[], real, real, vector)
+real wiener_lpdf(row_vector, real[], real, real, row_vector)
+real wiener_lpdf(row_vector, real[], real, real, real[])
+real wiener_lpdf(row_vector, real[], real, vector, real)
+real wiener_lpdf(row_vector, real[], real, vector, vector)
+real wiener_lpdf(row_vector, real[], real, vector, row_vector)
+real wiener_lpdf(row_vector, real[], real, vector, real[])
+real wiener_lpdf(row_vector, real[], real, row_vector, real)
+real wiener_lpdf(row_vector, real[], real, row_vector, vector)
+real wiener_lpdf(row_vector, real[], real, row_vector, row_vector)
+real wiener_lpdf(row_vector, real[], real, row_vector, real[])
+real wiener_lpdf(row_vector, real[], real, real[], real)
+real wiener_lpdf(row_vector, real[], real, real[], vector)
+real wiener_lpdf(row_vector, real[], real, real[], row_vector)
+real wiener_lpdf(row_vector, real[], real, real[], real[])
+real wiener_lpdf(row_vector, real[], vector, real, real)
+real wiener_lpdf(row_vector, real[], vector, real, vector)
+real wiener_lpdf(row_vector, real[], vector, real, row_vector)
+real wiener_lpdf(row_vector, real[], vector, real, real[])
+real wiener_lpdf(row_vector, real[], vector, vector, real)
+real wiener_lpdf(row_vector, real[], vector, vector, vector)
+real wiener_lpdf(row_vector, real[], vector, vector, row_vector)
+real wiener_lpdf(row_vector, real[], vector, vector, real[])
+real wiener_lpdf(row_vector, real[], vector, row_vector, real)
+real wiener_lpdf(row_vector, real[], vector, row_vector, vector)
+real wiener_lpdf(row_vector, real[], vector, row_vector, row_vector)
+real wiener_lpdf(row_vector, real[], vector, row_vector, real[])
+real wiener_lpdf(row_vector, real[], vector, real[], real)
+real wiener_lpdf(row_vector, real[], vector, real[], vector)
+real wiener_lpdf(row_vector, real[], vector, real[], row_vector)
+real wiener_lpdf(row_vector, real[], vector, real[], real[])
+real wiener_lpdf(row_vector, real[], row_vector, real, real)
+real wiener_lpdf(row_vector, real[], row_vector, real, vector)
+real wiener_lpdf(row_vector, real[], row_vector, real, row_vector)
+real wiener_lpdf(row_vector, real[], row_vector, real, real[])
+real wiener_lpdf(row_vector, real[], row_vector, vector, real)
+real wiener_lpdf(row_vector, real[], row_vector, vector, vector)
+real wiener_lpdf(row_vector, real[], row_vector, vector, row_vector)
+real wiener_lpdf(row_vector, real[], row_vector, vector, real[])
+real wiener_lpdf(row_vector, real[], row_vector, row_vector, real)
+real wiener_lpdf(row_vector, real[], row_vector, row_vector, vector)
+real wiener_lpdf(row_vector, real[], row_vector, row_vector, row_vector)
+real wiener_lpdf(row_vector, real[], row_vector, row_vector, real[])
+real wiener_lpdf(row_vector, real[], row_vector, real[], real)
+real wiener_lpdf(row_vector, real[], row_vector, real[], vector)
+real wiener_lpdf(row_vector, real[], row_vector, real[], row_vector)
+real wiener_lpdf(row_vector, real[], row_vector, real[], real[])
+real wiener_lpdf(row_vector, real[], real[], real, real)
+real wiener_lpdf(row_vector, real[], real[], real, vector)
+real wiener_lpdf(row_vector, real[], real[], real, row_vector)
+real wiener_lpdf(row_vector, real[], real[], real, real[])
+real wiener_lpdf(row_vector, real[], real[], vector, real)
+real wiener_lpdf(row_vector, real[], real[], vector, vector)
+real wiener_lpdf(row_vector, real[], real[], vector, row_vector)
+real wiener_lpdf(row_vector, real[], real[], vector, real[])
+real wiener_lpdf(row_vector, real[], real[], row_vector, real)
+real wiener_lpdf(row_vector, real[], real[], row_vector, vector)
+real wiener_lpdf(row_vector, real[], real[], row_vector, row_vector)
+real wiener_lpdf(row_vector, real[], real[], row_vector, real[])
+real wiener_lpdf(row_vector, real[], real[], real[], real)
+real wiener_lpdf(row_vector, real[], real[], real[], vector)
+real wiener_lpdf(row_vector, real[], real[], real[], row_vector)
+real wiener_lpdf(row_vector, real[], real[], real[], real[])
+real wiener_lpdf(real[], real, real, real, vector)
+real wiener_lpdf(real[], real, real, real, row_vector)
+real wiener_lpdf(real[], real, real, vector, real)
+real wiener_lpdf(real[], real, real, vector, vector)
+real wiener_lpdf(real[], real, real, vector, row_vector)
+real wiener_lpdf(real[], real, real, vector, real[])
+real wiener_lpdf(real[], real, real, row_vector, real)
+real wiener_lpdf(real[], real, real, row_vector, vector)
+real wiener_lpdf(real[], real, real, row_vector, row_vector)
+real wiener_lpdf(real[], real, real, row_vector, real[])
+real wiener_lpdf(real[], real, real, real[], vector)
+real wiener_lpdf(real[], real, real, real[], row_vector)
+real wiener_lpdf(real[], real, vector, real, real)
+real wiener_lpdf(real[], real, vector, real, vector)
+real wiener_lpdf(real[], real, vector, real, row_vector)
+real wiener_lpdf(real[], real, vector, real, real[])
+real wiener_lpdf(real[], real, vector, vector, real)
+real wiener_lpdf(real[], real, vector, vector, vector)
+real wiener_lpdf(real[], real, vector, vector, row_vector)
+real wiener_lpdf(real[], real, vector, vector, real[])
+real wiener_lpdf(real[], real, vector, row_vector, real)
+real wiener_lpdf(real[], real, vector, row_vector, vector)
+real wiener_lpdf(real[], real, vector, row_vector, row_vector)
+real wiener_lpdf(real[], real, vector, row_vector, real[])
+real wiener_lpdf(real[], real, vector, real[], real)
+real wiener_lpdf(real[], real, vector, real[], vector)
+real wiener_lpdf(real[], real, vector, real[], row_vector)
+real wiener_lpdf(real[], real, vector, real[], real[])
+real wiener_lpdf(real[], real, row_vector, real, real)
+real wiener_lpdf(real[], real, row_vector, real, vector)
+real wiener_lpdf(real[], real, row_vector, real, row_vector)
+real wiener_lpdf(real[], real, row_vector, real, real[])
+real wiener_lpdf(real[], real, row_vector, vector, real)
+real wiener_lpdf(real[], real, row_vector, vector, vector)
+real wiener_lpdf(real[], real, row_vector, vector, row_vector)
+real wiener_lpdf(real[], real, row_vector, vector, real[])
+real wiener_lpdf(real[], real, row_vector, row_vector, real)
+real wiener_lpdf(real[], real, row_vector, row_vector, vector)
+real wiener_lpdf(real[], real, row_vector, row_vector, row_vector)
+real wiener_lpdf(real[], real, row_vector, row_vector, real[])
+real wiener_lpdf(real[], real, row_vector, real[], real)
+real wiener_lpdf(real[], real, row_vector, real[], vector)
+real wiener_lpdf(real[], real, row_vector, real[], row_vector)
+real wiener_lpdf(real[], real, row_vector, real[], real[])
+real wiener_lpdf(real[], real, real[], real, vector)
+real wiener_lpdf(real[], real, real[], real, row_vector)
+real wiener_lpdf(real[], real, real[], vector, real)
+real wiener_lpdf(real[], real, real[], vector, vector)
+real wiener_lpdf(real[], real, real[], vector, row_vector)
+real wiener_lpdf(real[], real, real[], vector, real[])
+real wiener_lpdf(real[], real, real[], row_vector, real)
+real wiener_lpdf(real[], real, real[], row_vector, vector)
+real wiener_lpdf(real[], real, real[], row_vector, row_vector)
+real wiener_lpdf(real[], real, real[], row_vector, real[])
+real wiener_lpdf(real[], real, real[], real[], vector)
+real wiener_lpdf(real[], real, real[], real[], row_vector)
+real wiener_lpdf(real[], vector, real, real, real)
+real wiener_lpdf(real[], vector, real, real, vector)
+real wiener_lpdf(real[], vector, real, real, row_vector)
+real wiener_lpdf(real[], vector, real, real, real[])
+real wiener_lpdf(real[], vector, real, vector, real)
+real wiener_lpdf(real[], vector, real, vector, vector)
+real wiener_lpdf(real[], vector, real, vector, row_vector)
+real wiener_lpdf(real[], vector, real, vector, real[])
+real wiener_lpdf(real[], vector, real, row_vector, real)
+real wiener_lpdf(real[], vector, real, row_vector, vector)
+real wiener_lpdf(real[], vector, real, row_vector, row_vector)
+real wiener_lpdf(real[], vector, real, row_vector, real[])
+real wiener_lpdf(real[], vector, real, real[], real)
+real wiener_lpdf(real[], vector, real, real[], vector)
+real wiener_lpdf(real[], vector, real, real[], row_vector)
+real wiener_lpdf(real[], vector, real, real[], real[])
+real wiener_lpdf(real[], vector, vector, real, real)
+real wiener_lpdf(real[], vector, vector, real, vector)
+real wiener_lpdf(real[], vector, vector, real, row_vector)
+real wiener_lpdf(real[], vector, vector, real, real[])
+real wiener_lpdf(real[], vector, vector, vector, real)
+real wiener_lpdf(real[], vector, vector, vector, vector)
+real wiener_lpdf(real[], vector, vector, vector, row_vector)
+real wiener_lpdf(real[], vector, vector, vector, real[])
+real wiener_lpdf(real[], vector, vector, row_vector, real)
+real wiener_lpdf(real[], vector, vector, row_vector, vector)
+real wiener_lpdf(real[], vector, vector, row_vector, row_vector)
+real wiener_lpdf(real[], vector, vector, row_vector, real[])
+real wiener_lpdf(real[], vector, vector, real[], real)
+real wiener_lpdf(real[], vector, vector, real[], vector)
+real wiener_lpdf(real[], vector, vector, real[], row_vector)
+real wiener_lpdf(real[], vector, vector, real[], real[])
+real wiener_lpdf(real[], vector, row_vector, real, real)
+real wiener_lpdf(real[], vector, row_vector, real, vector)
+real wiener_lpdf(real[], vector, row_vector, real, row_vector)
+real wiener_lpdf(real[], vector, row_vector, real, real[])
+real wiener_lpdf(real[], vector, row_vector, vector, real)
+real wiener_lpdf(real[], vector, row_vector, vector, vector)
+real wiener_lpdf(real[], vector, row_vector, vector, row_vector)
+real wiener_lpdf(real[], vector, row_vector, vector, real[])
+real wiener_lpdf(real[], vector, row_vector, row_vector, real)
+real wiener_lpdf(real[], vector, row_vector, row_vector, vector)
+real wiener_lpdf(real[], vector, row_vector, row_vector, row_vector)
+real wiener_lpdf(real[], vector, row_vector, row_vector, real[])
+real wiener_lpdf(real[], vector, row_vector, real[], real)
+real wiener_lpdf(real[], vector, row_vector, real[], vector)
+real wiener_lpdf(real[], vector, row_vector, real[], row_vector)
+real wiener_lpdf(real[], vector, row_vector, real[], real[])
+real wiener_lpdf(real[], vector, real[], real, real)
+real wiener_lpdf(real[], vector, real[], real, vector)
+real wiener_lpdf(real[], vector, real[], real, row_vector)
+real wiener_lpdf(real[], vector, real[], real, real[])
+real wiener_lpdf(real[], vector, real[], vector, real)
+real wiener_lpdf(real[], vector, real[], vector, vector)
+real wiener_lpdf(real[], vector, real[], vector, row_vector)
+real wiener_lpdf(real[], vector, real[], vector, real[])
+real wiener_lpdf(real[], vector, real[], row_vector, real)
+real wiener_lpdf(real[], vector, real[], row_vector, vector)
+real wiener_lpdf(real[], vector, real[], row_vector, row_vector)
+real wiener_lpdf(real[], vector, real[], row_vector, real[])
+real wiener_lpdf(real[], vector, real[], real[], real)
+real wiener_lpdf(real[], vector, real[], real[], vector)
+real wiener_lpdf(real[], vector, real[], real[], row_vector)
+real wiener_lpdf(real[], vector, real[], real[], real[])
+real wiener_lpdf(real[], row_vector, real, real, real)
+real wiener_lpdf(real[], row_vector, real, real, vector)
+real wiener_lpdf(real[], row_vector, real, real, row_vector)
+real wiener_lpdf(real[], row_vector, real, real, real[])
+real wiener_lpdf(real[], row_vector, real, vector, real)
+real wiener_lpdf(real[], row_vector, real, vector, vector)
+real wiener_lpdf(real[], row_vector, real, vector, row_vector)
+real wiener_lpdf(real[], row_vector, real, vector, real[])
+real wiener_lpdf(real[], row_vector, real, row_vector, real)
+real wiener_lpdf(real[], row_vector, real, row_vector, vector)
+real wiener_lpdf(real[], row_vector, real, row_vector, row_vector)
+real wiener_lpdf(real[], row_vector, real, row_vector, real[])
+real wiener_lpdf(real[], row_vector, real, real[], real)
+real wiener_lpdf(real[], row_vector, real, real[], vector)
+real wiener_lpdf(real[], row_vector, real, real[], row_vector)
+real wiener_lpdf(real[], row_vector, real, real[], real[])
+real wiener_lpdf(real[], row_vector, vector, real, real)
+real wiener_lpdf(real[], row_vector, vector, real, vector)
+real wiener_lpdf(real[], row_vector, vector, real, row_vector)
+real wiener_lpdf(real[], row_vector, vector, real, real[])
+real wiener_lpdf(real[], row_vector, vector, vector, real)
+real wiener_lpdf(real[], row_vector, vector, vector, vector)
+real wiener_lpdf(real[], row_vector, vector, vector, row_vector)
+real wiener_lpdf(real[], row_vector, vector, vector, real[])
+real wiener_lpdf(real[], row_vector, vector, row_vector, real)
+real wiener_lpdf(real[], row_vector, vector, row_vector, vector)
+real wiener_lpdf(real[], row_vector, vector, row_vector, row_vector)
+real wiener_lpdf(real[], row_vector, vector, row_vector, real[])
+real wiener_lpdf(real[], row_vector, vector, real[], real)
+real wiener_lpdf(real[], row_vector, vector, real[], vector)
+real wiener_lpdf(real[], row_vector, vector, real[], row_vector)
+real wiener_lpdf(real[], row_vector, vector, real[], real[])
+real wiener_lpdf(real[], row_vector, row_vector, real, real)
+real wiener_lpdf(real[], row_vector, row_vector, real, vector)
+real wiener_lpdf(real[], row_vector, row_vector, real, row_vector)
+real wiener_lpdf(real[], row_vector, row_vector, real, real[])
+real wiener_lpdf(real[], row_vector, row_vector, vector, real)
+real wiener_lpdf(real[], row_vector, row_vector, vector, vector)
+real wiener_lpdf(real[], row_vector, row_vector, vector, row_vector)
+real wiener_lpdf(real[], row_vector, row_vector, vector, real[])
+real wiener_lpdf(real[], row_vector, row_vector, row_vector, real)
+real wiener_lpdf(real[], row_vector, row_vector, row_vector, vector)
+real wiener_lpdf(real[], row_vector, row_vector, row_vector, row_vector)
+real wiener_lpdf(real[], row_vector, row_vector, row_vector, real[])
+real wiener_lpdf(real[], row_vector, row_vector, real[], real)
+real wiener_lpdf(real[], row_vector, row_vector, real[], vector)
+real wiener_lpdf(real[], row_vector, row_vector, real[], row_vector)
+real wiener_lpdf(real[], row_vector, row_vector, real[], real[])
+real wiener_lpdf(real[], row_vector, real[], real, real)
+real wiener_lpdf(real[], row_vector, real[], real, vector)
+real wiener_lpdf(real[], row_vector, real[], real, row_vector)
+real wiener_lpdf(real[], row_vector, real[], real, real[])
+real wiener_lpdf(real[], row_vector, real[], vector, real)
+real wiener_lpdf(real[], row_vector, real[], vector, vector)
+real wiener_lpdf(real[], row_vector, real[], vector, row_vector)
+real wiener_lpdf(real[], row_vector, real[], vector, real[])
+real wiener_lpdf(real[], row_vector, real[], row_vector, real)
+real wiener_lpdf(real[], row_vector, real[], row_vector, vector)
+real wiener_lpdf(real[], row_vector, real[], row_vector, row_vector)
+real wiener_lpdf(real[], row_vector, real[], row_vector, real[])
+real wiener_lpdf(real[], row_vector, real[], real[], real)
+real wiener_lpdf(real[], row_vector, real[], real[], vector)
+real wiener_lpdf(real[], row_vector, real[], real[], row_vector)
+real wiener_lpdf(real[], row_vector, real[], real[], real[])
+real wiener_lpdf(real[], real[], real, real, vector)
+real wiener_lpdf(real[], real[], real, real, row_vector)
+real wiener_lpdf(real[], real[], real, vector, real)
+real wiener_lpdf(real[], real[], real, vector, vector)
+real wiener_lpdf(real[], real[], real, vector, row_vector)
+real wiener_lpdf(real[], real[], real, vector, real[])
+real wiener_lpdf(real[], real[], real, row_vector, real)
+real wiener_lpdf(real[], real[], real, row_vector, vector)
+real wiener_lpdf(real[], real[], real, row_vector, row_vector)
+real wiener_lpdf(real[], real[], real, row_vector, real[])
+real wiener_lpdf(real[], real[], real, real[], vector)
+real wiener_lpdf(real[], real[], real, real[], row_vector)
+real wiener_lpdf(real[], real[], vector, real, real)
+real wiener_lpdf(real[], real[], vector, real, vector)
+real wiener_lpdf(real[], real[], vector, real, row_vector)
+real wiener_lpdf(real[], real[], vector, real, real[])
+real wiener_lpdf(real[], real[], vector, vector, real)
+real wiener_lpdf(real[], real[], vector, vector, vector)
+real wiener_lpdf(real[], real[], vector, vector, row_vector)
+real wiener_lpdf(real[], real[], vector, vector, real[])
+real wiener_lpdf(real[], real[], vector, row_vector, real)
+real wiener_lpdf(real[], real[], vector, row_vector, vector)
+real wiener_lpdf(real[], real[], vector, row_vector, row_vector)
+real wiener_lpdf(real[], real[], vector, row_vector, real[])
+real wiener_lpdf(real[], real[], vector, real[], real)
+real wiener_lpdf(real[], real[], vector, real[], vector)
+real wiener_lpdf(real[], real[], vector, real[], row_vector)
+real wiener_lpdf(real[], real[], vector, real[], real[])
+real wiener_lpdf(real[], real[], row_vector, real, real)
+real wiener_lpdf(real[], real[], row_vector, real, vector)
+real wiener_lpdf(real[], real[], row_vector, real, row_vector)
+real wiener_lpdf(real[], real[], row_vector, real, real[])
+real wiener_lpdf(real[], real[], row_vector, vector, real)
+real wiener_lpdf(real[], real[], row_vector, vector, vector)
+real wiener_lpdf(real[], real[], row_vector, vector, row_vector)
+real wiener_lpdf(real[], real[], row_vector, vector, real[])
+real wiener_lpdf(real[], real[], row_vector, row_vector, real)
+real wiener_lpdf(real[], real[], row_vector, row_vector, vector)
+real wiener_lpdf(real[], real[], row_vector, row_vector, row_vector)
+real wiener_lpdf(real[], real[], row_vector, row_vector, real[])
+real wiener_lpdf(real[], real[], row_vector, real[], real)
+real wiener_lpdf(real[], real[], row_vector, real[], vector)
+real wiener_lpdf(real[], real[], row_vector, real[], row_vector)
+real wiener_lpdf(real[], real[], row_vector, real[], real[])
+real wiener_lpdf(real[], real[], real[], real, vector)
+real wiener_lpdf(real[], real[], real[], real, row_vector)
+real wiener_lpdf(real[], real[], real[], vector, real)
+real wiener_lpdf(real[], real[], real[], vector, vector)
+real wiener_lpdf(real[], real[], real[], vector, row_vector)
+real wiener_lpdf(real[], real[], real[], vector, real[])
+real wiener_lpdf(real[], real[], real[], row_vector, real)
+real wiener_lpdf(real[], real[], real[], row_vector, vector)
+real wiener_lpdf(real[], real[], real[], row_vector, row_vector)
+real wiener_lpdf(real[], real[], real[], row_vector, real[])
+real wiener_lpdf(real[], real[], real[], real[], vector)
+real wiener_lpdf(real[], real[], real[], real[], row_vector)
+real wishart_log(matrix, real, matrix)
+real wishart_lpdf(matrix, real, matrix)
+matrix wishart_rng(real, matrix)