// Generated by using Rcpp::compileAttributes() -> do not edit by hand
// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393

#ifndef RCPP_revdbayes_RCPPEXPORTS_H_GEN_
#define RCPP_revdbayes_RCPPEXPORTS_H_GEN_

#include <RcppArmadillo.h>
#include <Rcpp.h>

namespace revdbayes {

    using namespace Rcpp;

    namespace {
        void validateSignature(const char* sig) {
            Rcpp::Function require = Rcpp::Environment::base_env()["require"];
            require("revdbayes", Rcpp::Named("quietly") = true);
            typedef int(*Ptr_validate)(const char*);
            static Ptr_validate p_validate = (Ptr_validate)
                R_GetCCallable("revdbayes", "_revdbayes_RcppExport_validate");
            if (!p_validate(sig)) {
                throw Rcpp::function_not_exported(
                    "C++ function with signature '" + std::string(sig) + "' not found in revdbayes");
            }
        }
    }

    inline bool any_nonpos(const Rcpp::NumericVector& x) {
        typedef SEXP(*Ptr_any_nonpos)(SEXP);
        static Ptr_any_nonpos p_any_nonpos = NULL;
        if (p_any_nonpos == NULL) {
            validateSignature("bool(*any_nonpos)(const Rcpp::NumericVector&)");
            p_any_nonpos = (Ptr_any_nonpos)R_GetCCallable("revdbayes", "_revdbayes_any_nonpos");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_any_nonpos(Shield<SEXP>(Rcpp::wrap(x)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<bool >(rcpp_result_gen);
    }

    inline double cpp_gp_loglik(const Rcpp::NumericVector& x, const Rcpp::List& ss) {
        typedef SEXP(*Ptr_cpp_gp_loglik)(SEXP,SEXP);
        static Ptr_cpp_gp_loglik p_cpp_gp_loglik = NULL;
        if (p_cpp_gp_loglik == NULL) {
            validateSignature("double(*cpp_gp_loglik)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gp_loglik = (Ptr_cpp_gp_loglik)R_GetCCallable("revdbayes", "_revdbayes_cpp_gp_loglik");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gp_loglik(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ss)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gev_loglik(const Rcpp::NumericVector& x, const Rcpp::List& ss) {
        typedef SEXP(*Ptr_cpp_gev_loglik)(SEXP,SEXP);
        static Ptr_cpp_gev_loglik p_cpp_gev_loglik = NULL;
        if (p_cpp_gev_loglik == NULL) {
            validateSignature("double(*cpp_gev_loglik)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gev_loglik = (Ptr_cpp_gev_loglik)R_GetCCallable("revdbayes", "_revdbayes_cpp_gev_loglik");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gev_loglik(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ss)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_os_loglik(const Rcpp::NumericVector& x, const Rcpp::List& ss) {
        typedef SEXP(*Ptr_cpp_os_loglik)(SEXP,SEXP);
        static Ptr_cpp_os_loglik p_cpp_os_loglik = NULL;
        if (p_cpp_os_loglik == NULL) {
            validateSignature("double(*cpp_os_loglik)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_os_loglik = (Ptr_cpp_os_loglik)R_GetCCallable("revdbayes", "_revdbayes_cpp_os_loglik");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_os_loglik(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ss)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_pp_loglik(const Rcpp::NumericVector& x, const Rcpp::List& ss) {
        typedef SEXP(*Ptr_cpp_pp_loglik)(SEXP,SEXP);
        static Ptr_cpp_pp_loglik p_cpp_pp_loglik = NULL;
        if (p_cpp_pp_loglik == NULL) {
            validateSignature("double(*cpp_pp_loglik)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_pp_loglik = (Ptr_cpp_pp_loglik)R_GetCCallable("revdbayes", "_revdbayes_cpp_pp_loglik");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_pp_loglik(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ss)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gp_norm(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gp_norm)(SEXP,SEXP);
        static Ptr_cpp_gp_norm p_cpp_gp_norm = NULL;
        if (p_cpp_gp_norm == NULL) {
            validateSignature("double(*cpp_gp_norm)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gp_norm = (Ptr_cpp_gp_norm)R_GetCCallable("revdbayes", "_revdbayes_cpp_gp_norm");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gp_norm(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gp_mdi(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gp_mdi)(SEXP,SEXP);
        static Ptr_cpp_gp_mdi p_cpp_gp_mdi = NULL;
        if (p_cpp_gp_mdi == NULL) {
            validateSignature("double(*cpp_gp_mdi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gp_mdi = (Ptr_cpp_gp_mdi)R_GetCCallable("revdbayes", "_revdbayes_cpp_gp_mdi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gp_mdi(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gp_flat(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gp_flat)(SEXP,SEXP);
        static Ptr_cpp_gp_flat p_cpp_gp_flat = NULL;
        if (p_cpp_gp_flat == NULL) {
            validateSignature("double(*cpp_gp_flat)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gp_flat = (Ptr_cpp_gp_flat)R_GetCCallable("revdbayes", "_revdbayes_cpp_gp_flat");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gp_flat(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gp_flatflat(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gp_flatflat)(SEXP,SEXP);
        static Ptr_cpp_gp_flatflat p_cpp_gp_flatflat = NULL;
        if (p_cpp_gp_flatflat == NULL) {
            validateSignature("double(*cpp_gp_flatflat)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gp_flatflat = (Ptr_cpp_gp_flatflat)R_GetCCallable("revdbayes", "_revdbayes_cpp_gp_flatflat");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gp_flatflat(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gp_jeffreys(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gp_jeffreys)(SEXP,SEXP);
        static Ptr_cpp_gp_jeffreys p_cpp_gp_jeffreys = NULL;
        if (p_cpp_gp_jeffreys == NULL) {
            validateSignature("double(*cpp_gp_jeffreys)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gp_jeffreys = (Ptr_cpp_gp_jeffreys)R_GetCCallable("revdbayes", "_revdbayes_cpp_gp_jeffreys");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gp_jeffreys(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gp_beta(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gp_beta)(SEXP,SEXP);
        static Ptr_cpp_gp_beta p_cpp_gp_beta = NULL;
        if (p_cpp_gp_beta == NULL) {
            validateSignature("double(*cpp_gp_beta)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gp_beta = (Ptr_cpp_gp_beta)R_GetCCallable("revdbayes", "_revdbayes_cpp_gp_beta");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gp_beta(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gev_norm(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gev_norm)(SEXP,SEXP);
        static Ptr_cpp_gev_norm p_cpp_gev_norm = NULL;
        if (p_cpp_gev_norm == NULL) {
            validateSignature("double(*cpp_gev_norm)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gev_norm = (Ptr_cpp_gev_norm)R_GetCCallable("revdbayes", "_revdbayes_cpp_gev_norm");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gev_norm(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gev_loglognorm(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gev_loglognorm)(SEXP,SEXP);
        static Ptr_cpp_gev_loglognorm p_cpp_gev_loglognorm = NULL;
        if (p_cpp_gev_loglognorm == NULL) {
            validateSignature("double(*cpp_gev_loglognorm)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gev_loglognorm = (Ptr_cpp_gev_loglognorm)R_GetCCallable("revdbayes", "_revdbayes_cpp_gev_loglognorm");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gev_loglognorm(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gev_mdi(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gev_mdi)(SEXP,SEXP);
        static Ptr_cpp_gev_mdi p_cpp_gev_mdi = NULL;
        if (p_cpp_gev_mdi == NULL) {
            validateSignature("double(*cpp_gev_mdi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gev_mdi = (Ptr_cpp_gev_mdi)R_GetCCallable("revdbayes", "_revdbayes_cpp_gev_mdi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gev_mdi(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gev_flat(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gev_flat)(SEXP,SEXP);
        static Ptr_cpp_gev_flat p_cpp_gev_flat = NULL;
        if (p_cpp_gev_flat == NULL) {
            validateSignature("double(*cpp_gev_flat)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gev_flat = (Ptr_cpp_gev_flat)R_GetCCallable("revdbayes", "_revdbayes_cpp_gev_flat");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gev_flat(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gev_flatflat(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gev_flatflat)(SEXP,SEXP);
        static Ptr_cpp_gev_flatflat p_cpp_gev_flatflat = NULL;
        if (p_cpp_gev_flatflat == NULL) {
            validateSignature("double(*cpp_gev_flatflat)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gev_flatflat = (Ptr_cpp_gev_flatflat)R_GetCCallable("revdbayes", "_revdbayes_cpp_gev_flatflat");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gev_flatflat(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gev_beta(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gev_beta)(SEXP,SEXP);
        static Ptr_cpp_gev_beta p_cpp_gev_beta = NULL;
        if (p_cpp_gev_beta == NULL) {
            validateSignature("double(*cpp_gev_beta)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gev_beta = (Ptr_cpp_gev_beta)R_GetCCallable("revdbayes", "_revdbayes_cpp_gev_beta");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gev_beta(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline Rcpp::NumericVector lgdgev_cpp(const Rcpp::NumericVector& x, const double& loc, const double& scale, const double& shape) {
        typedef SEXP(*Ptr_lgdgev_cpp)(SEXP,SEXP,SEXP,SEXP);
        static Ptr_lgdgev_cpp p_lgdgev_cpp = NULL;
        if (p_lgdgev_cpp == NULL) {
            validateSignature("Rcpp::NumericVector(*lgdgev_cpp)(const Rcpp::NumericVector&,const double&,const double&,const double&)");
            p_lgdgev_cpp = (Ptr_lgdgev_cpp)R_GetCCallable("revdbayes", "_revdbayes_lgdgev_cpp");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_lgdgev_cpp(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(loc)), Shield<SEXP>(Rcpp::wrap(scale)), Shield<SEXP>(Rcpp::wrap(shape)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<Rcpp::NumericVector >(rcpp_result_gen);
    }

    inline Rcpp::NumericVector pgev_cpp(const Rcpp::NumericVector& q, const double& loc, const double& scale, const double& shape) {
        typedef SEXP(*Ptr_pgev_cpp)(SEXP,SEXP,SEXP,SEXP);
        static Ptr_pgev_cpp p_pgev_cpp = NULL;
        if (p_pgev_cpp == NULL) {
            validateSignature("Rcpp::NumericVector(*pgev_cpp)(const Rcpp::NumericVector&,const double&,const double&,const double&)");
            p_pgev_cpp = (Ptr_pgev_cpp)R_GetCCallable("revdbayes", "_revdbayes_pgev_cpp");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pgev_cpp(Shield<SEXP>(Rcpp::wrap(q)), Shield<SEXP>(Rcpp::wrap(loc)), Shield<SEXP>(Rcpp::wrap(scale)), Shield<SEXP>(Rcpp::wrap(shape)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<Rcpp::NumericVector >(rcpp_result_gen);
    }

    inline Rcpp::NumericVector qgev_cpp(const Rcpp::NumericVector& p, const double& loc, const double& scale, const double& shape) {
        typedef SEXP(*Ptr_qgev_cpp)(SEXP,SEXP,SEXP,SEXP);
        static Ptr_qgev_cpp p_qgev_cpp = NULL;
        if (p_qgev_cpp == NULL) {
            validateSignature("Rcpp::NumericVector(*qgev_cpp)(const Rcpp::NumericVector&,const double&,const double&,const double&)");
            p_qgev_cpp = (Ptr_qgev_cpp)R_GetCCallable("revdbayes", "_revdbayes_qgev_cpp");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_qgev_cpp(Shield<SEXP>(Rcpp::wrap(p)), Shield<SEXP>(Rcpp::wrap(loc)), Shield<SEXP>(Rcpp::wrap(scale)), Shield<SEXP>(Rcpp::wrap(shape)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<Rcpp::NumericVector >(rcpp_result_gen);
    }

    inline double cpp_gev_prob(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gev_prob)(SEXP,SEXP);
        static Ptr_cpp_gev_prob p_cpp_gev_prob = NULL;
        if (p_cpp_gev_prob == NULL) {
            validateSignature("double(*cpp_gev_prob)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gev_prob = (Ptr_cpp_gev_prob)R_GetCCallable("revdbayes", "_revdbayes_cpp_gev_prob");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gev_prob(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double cpp_gev_quant(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_cpp_gev_quant)(SEXP,SEXP);
        static Ptr_cpp_gev_quant p_cpp_gev_quant = NULL;
        if (p_cpp_gev_quant == NULL) {
            validateSignature("double(*cpp_gev_quant)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_cpp_gev_quant = (Ptr_cpp_gev_quant)R_GetCCallable("revdbayes", "_revdbayes_cpp_gev_quant");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpp_gev_quant(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gp_user_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_user_logpost)(SEXP,SEXP);
        static Ptr_gp_user_logpost p_gp_user_logpost = NULL;
        if (p_gp_user_logpost == NULL) {
            validateSignature("double(*gp_user_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_user_logpost = (Ptr_gp_user_logpost)R_GetCCallable("revdbayes", "_revdbayes_gp_user_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_user_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_user_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_user_logpost)(SEXP,SEXP);
        static Ptr_gev_user_logpost p_gev_user_logpost = NULL;
        if (p_gev_user_logpost == NULL) {
            validateSignature("double(*gev_user_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_user_logpost = (Ptr_gev_user_logpost)R_GetCCallable("revdbayes", "_revdbayes_gev_user_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_user_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_user_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_user_logpost)(SEXP,SEXP);
        static Ptr_os_user_logpost p_os_user_logpost = NULL;
        if (p_os_user_logpost == NULL) {
            validateSignature("double(*os_user_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_user_logpost = (Ptr_os_user_logpost)R_GetCCallable("revdbayes", "_revdbayes_os_user_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_user_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_user_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_user_logpost)(SEXP,SEXP);
        static Ptr_pp_user_logpost p_pp_user_logpost = NULL;
        if (p_pp_user_logpost == NULL) {
            validateSignature("double(*pp_user_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_user_logpost = (Ptr_pp_user_logpost)R_GetCCallable("revdbayes", "_revdbayes_pp_user_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_user_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gp_mdi_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_mdi_logpost)(SEXP,SEXP);
        static Ptr_gp_mdi_logpost p_gp_mdi_logpost = NULL;
        if (p_gp_mdi_logpost == NULL) {
            validateSignature("double(*gp_mdi_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_mdi_logpost = (Ptr_gp_mdi_logpost)R_GetCCallable("revdbayes", "_revdbayes_gp_mdi_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_mdi_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gp_norm_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_norm_logpost)(SEXP,SEXP);
        static Ptr_gp_norm_logpost p_gp_norm_logpost = NULL;
        if (p_gp_norm_logpost == NULL) {
            validateSignature("double(*gp_norm_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_norm_logpost = (Ptr_gp_norm_logpost)R_GetCCallable("revdbayes", "_revdbayes_gp_norm_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_norm_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gp_flat_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_flat_logpost)(SEXP,SEXP);
        static Ptr_gp_flat_logpost p_gp_flat_logpost = NULL;
        if (p_gp_flat_logpost == NULL) {
            validateSignature("double(*gp_flat_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_flat_logpost = (Ptr_gp_flat_logpost)R_GetCCallable("revdbayes", "_revdbayes_gp_flat_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_flat_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gp_flatflat_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_flatflat_logpost)(SEXP,SEXP);
        static Ptr_gp_flatflat_logpost p_gp_flatflat_logpost = NULL;
        if (p_gp_flatflat_logpost == NULL) {
            validateSignature("double(*gp_flatflat_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_flatflat_logpost = (Ptr_gp_flatflat_logpost)R_GetCCallable("revdbayes", "_revdbayes_gp_flatflat_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_flatflat_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gp_jeffreys_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_jeffreys_logpost)(SEXP,SEXP);
        static Ptr_gp_jeffreys_logpost p_gp_jeffreys_logpost = NULL;
        if (p_gp_jeffreys_logpost == NULL) {
            validateSignature("double(*gp_jeffreys_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_jeffreys_logpost = (Ptr_gp_jeffreys_logpost)R_GetCCallable("revdbayes", "_revdbayes_gp_jeffreys_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_jeffreys_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gp_beta_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_beta_logpost)(SEXP,SEXP);
        static Ptr_gp_beta_logpost p_gp_beta_logpost = NULL;
        if (p_gp_beta_logpost == NULL) {
            validateSignature("double(*gp_beta_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_beta_logpost = (Ptr_gp_beta_logpost)R_GetCCallable("revdbayes", "_revdbayes_gp_beta_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_beta_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_mdi_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_mdi_logpost)(SEXP,SEXP);
        static Ptr_gev_mdi_logpost p_gev_mdi_logpost = NULL;
        if (p_gev_mdi_logpost == NULL) {
            validateSignature("double(*gev_mdi_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_mdi_logpost = (Ptr_gev_mdi_logpost)R_GetCCallable("revdbayes", "_revdbayes_gev_mdi_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_mdi_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_norm_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_norm_logpost)(SEXP,SEXP);
        static Ptr_gev_norm_logpost p_gev_norm_logpost = NULL;
        if (p_gev_norm_logpost == NULL) {
            validateSignature("double(*gev_norm_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_norm_logpost = (Ptr_gev_norm_logpost)R_GetCCallable("revdbayes", "_revdbayes_gev_norm_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_norm_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_loglognorm_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_loglognorm_logpost)(SEXP,SEXP);
        static Ptr_gev_loglognorm_logpost p_gev_loglognorm_logpost = NULL;
        if (p_gev_loglognorm_logpost == NULL) {
            validateSignature("double(*gev_loglognorm_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_loglognorm_logpost = (Ptr_gev_loglognorm_logpost)R_GetCCallable("revdbayes", "_revdbayes_gev_loglognorm_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_loglognorm_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_flat_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_flat_logpost)(SEXP,SEXP);
        static Ptr_gev_flat_logpost p_gev_flat_logpost = NULL;
        if (p_gev_flat_logpost == NULL) {
            validateSignature("double(*gev_flat_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_flat_logpost = (Ptr_gev_flat_logpost)R_GetCCallable("revdbayes", "_revdbayes_gev_flat_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_flat_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_flatflat_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_flatflat_logpost)(SEXP,SEXP);
        static Ptr_gev_flatflat_logpost p_gev_flatflat_logpost = NULL;
        if (p_gev_flatflat_logpost == NULL) {
            validateSignature("double(*gev_flatflat_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_flatflat_logpost = (Ptr_gev_flatflat_logpost)R_GetCCallable("revdbayes", "_revdbayes_gev_flatflat_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_flatflat_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_beta_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_beta_logpost)(SEXP,SEXP);
        static Ptr_gev_beta_logpost p_gev_beta_logpost = NULL;
        if (p_gev_beta_logpost == NULL) {
            validateSignature("double(*gev_beta_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_beta_logpost = (Ptr_gev_beta_logpost)R_GetCCallable("revdbayes", "_revdbayes_gev_beta_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_beta_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_prob_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_prob_logpost)(SEXP,SEXP);
        static Ptr_gev_prob_logpost p_gev_prob_logpost = NULL;
        if (p_gev_prob_logpost == NULL) {
            validateSignature("double(*gev_prob_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_prob_logpost = (Ptr_gev_prob_logpost)R_GetCCallable("revdbayes", "_revdbayes_gev_prob_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_prob_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_quant_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_quant_logpost)(SEXP,SEXP);
        static Ptr_gev_quant_logpost p_gev_quant_logpost = NULL;
        if (p_gev_quant_logpost == NULL) {
            validateSignature("double(*gev_quant_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_quant_logpost = (Ptr_gev_quant_logpost)R_GetCCallable("revdbayes", "_revdbayes_gev_quant_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_quant_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_mdi_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_mdi_logpost)(SEXP,SEXP);
        static Ptr_pp_mdi_logpost p_pp_mdi_logpost = NULL;
        if (p_pp_mdi_logpost == NULL) {
            validateSignature("double(*pp_mdi_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_mdi_logpost = (Ptr_pp_mdi_logpost)R_GetCCallable("revdbayes", "_revdbayes_pp_mdi_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_mdi_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_norm_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_norm_logpost)(SEXP,SEXP);
        static Ptr_pp_norm_logpost p_pp_norm_logpost = NULL;
        if (p_pp_norm_logpost == NULL) {
            validateSignature("double(*pp_norm_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_norm_logpost = (Ptr_pp_norm_logpost)R_GetCCallable("revdbayes", "_revdbayes_pp_norm_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_norm_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_loglognorm_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_loglognorm_logpost)(SEXP,SEXP);
        static Ptr_pp_loglognorm_logpost p_pp_loglognorm_logpost = NULL;
        if (p_pp_loglognorm_logpost == NULL) {
            validateSignature("double(*pp_loglognorm_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_loglognorm_logpost = (Ptr_pp_loglognorm_logpost)R_GetCCallable("revdbayes", "_revdbayes_pp_loglognorm_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_loglognorm_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_flat_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_flat_logpost)(SEXP,SEXP);
        static Ptr_pp_flat_logpost p_pp_flat_logpost = NULL;
        if (p_pp_flat_logpost == NULL) {
            validateSignature("double(*pp_flat_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_flat_logpost = (Ptr_pp_flat_logpost)R_GetCCallable("revdbayes", "_revdbayes_pp_flat_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_flat_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_flatflat_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_flatflat_logpost)(SEXP,SEXP);
        static Ptr_pp_flatflat_logpost p_pp_flatflat_logpost = NULL;
        if (p_pp_flatflat_logpost == NULL) {
            validateSignature("double(*pp_flatflat_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_flatflat_logpost = (Ptr_pp_flatflat_logpost)R_GetCCallable("revdbayes", "_revdbayes_pp_flatflat_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_flatflat_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_beta_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_beta_logpost)(SEXP,SEXP);
        static Ptr_pp_beta_logpost p_pp_beta_logpost = NULL;
        if (p_pp_beta_logpost == NULL) {
            validateSignature("double(*pp_beta_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_beta_logpost = (Ptr_pp_beta_logpost)R_GetCCallable("revdbayes", "_revdbayes_pp_beta_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_beta_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_prob_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_prob_logpost)(SEXP,SEXP);
        static Ptr_pp_prob_logpost p_pp_prob_logpost = NULL;
        if (p_pp_prob_logpost == NULL) {
            validateSignature("double(*pp_prob_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_prob_logpost = (Ptr_pp_prob_logpost)R_GetCCallable("revdbayes", "_revdbayes_pp_prob_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_prob_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_quant_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_quant_logpost)(SEXP,SEXP);
        static Ptr_pp_quant_logpost p_pp_quant_logpost = NULL;
        if (p_pp_quant_logpost == NULL) {
            validateSignature("double(*pp_quant_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_quant_logpost = (Ptr_pp_quant_logpost)R_GetCCallable("revdbayes", "_revdbayes_pp_quant_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_quant_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_mdi_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_mdi_logpost)(SEXP,SEXP);
        static Ptr_os_mdi_logpost p_os_mdi_logpost = NULL;
        if (p_os_mdi_logpost == NULL) {
            validateSignature("double(*os_mdi_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_mdi_logpost = (Ptr_os_mdi_logpost)R_GetCCallable("revdbayes", "_revdbayes_os_mdi_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_mdi_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_norm_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_norm_logpost)(SEXP,SEXP);
        static Ptr_os_norm_logpost p_os_norm_logpost = NULL;
        if (p_os_norm_logpost == NULL) {
            validateSignature("double(*os_norm_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_norm_logpost = (Ptr_os_norm_logpost)R_GetCCallable("revdbayes", "_revdbayes_os_norm_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_norm_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_loglognorm_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_loglognorm_logpost)(SEXP,SEXP);
        static Ptr_os_loglognorm_logpost p_os_loglognorm_logpost = NULL;
        if (p_os_loglognorm_logpost == NULL) {
            validateSignature("double(*os_loglognorm_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_loglognorm_logpost = (Ptr_os_loglognorm_logpost)R_GetCCallable("revdbayes", "_revdbayes_os_loglognorm_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_loglognorm_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_flat_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_flat_logpost)(SEXP,SEXP);
        static Ptr_os_flat_logpost p_os_flat_logpost = NULL;
        if (p_os_flat_logpost == NULL) {
            validateSignature("double(*os_flat_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_flat_logpost = (Ptr_os_flat_logpost)R_GetCCallable("revdbayes", "_revdbayes_os_flat_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_flat_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_flatflat_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_flatflat_logpost)(SEXP,SEXP);
        static Ptr_os_flatflat_logpost p_os_flatflat_logpost = NULL;
        if (p_os_flatflat_logpost == NULL) {
            validateSignature("double(*os_flatflat_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_flatflat_logpost = (Ptr_os_flatflat_logpost)R_GetCCallable("revdbayes", "_revdbayes_os_flatflat_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_flatflat_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_beta_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_beta_logpost)(SEXP,SEXP);
        static Ptr_os_beta_logpost p_os_beta_logpost = NULL;
        if (p_os_beta_logpost == NULL) {
            validateSignature("double(*os_beta_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_beta_logpost = (Ptr_os_beta_logpost)R_GetCCallable("revdbayes", "_revdbayes_os_beta_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_beta_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_prob_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_prob_logpost)(SEXP,SEXP);
        static Ptr_os_prob_logpost p_os_prob_logpost = NULL;
        if (p_os_prob_logpost == NULL) {
            validateSignature("double(*os_prob_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_prob_logpost = (Ptr_os_prob_logpost)R_GetCCallable("revdbayes", "_revdbayes_os_prob_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_prob_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_quant_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_quant_logpost)(SEXP,SEXP);
        static Ptr_os_quant_logpost p_os_quant_logpost = NULL;
        if (p_os_quant_logpost == NULL) {
            validateSignature("double(*os_quant_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_quant_logpost = (Ptr_os_quant_logpost)R_GetCCallable("revdbayes", "_revdbayes_os_quant_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_quant_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline SEXP gp_logpost_xptr(std::string fstr) {
        typedef SEXP(*Ptr_gp_logpost_xptr)(SEXP);
        static Ptr_gp_logpost_xptr p_gp_logpost_xptr = NULL;
        if (p_gp_logpost_xptr == NULL) {
            validateSignature("SEXP(*gp_logpost_xptr)(std::string)");
            p_gp_logpost_xptr = (Ptr_gp_logpost_xptr)R_GetCCallable("revdbayes", "_revdbayes_gp_logpost_xptr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_logpost_xptr(Shield<SEXP>(Rcpp::wrap(fstr)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<SEXP >(rcpp_result_gen);
    }

    inline SEXP gev_logpost_xptr(std::string fstr) {
        typedef SEXP(*Ptr_gev_logpost_xptr)(SEXP);
        static Ptr_gev_logpost_xptr p_gev_logpost_xptr = NULL;
        if (p_gev_logpost_xptr == NULL) {
            validateSignature("SEXP(*gev_logpost_xptr)(std::string)");
            p_gev_logpost_xptr = (Ptr_gev_logpost_xptr)R_GetCCallable("revdbayes", "_revdbayes_gev_logpost_xptr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_logpost_xptr(Shield<SEXP>(Rcpp::wrap(fstr)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<SEXP >(rcpp_result_gen);
    }

    inline SEXP os_logpost_xptr(std::string fstr) {
        typedef SEXP(*Ptr_os_logpost_xptr)(SEXP);
        static Ptr_os_logpost_xptr p_os_logpost_xptr = NULL;
        if (p_os_logpost_xptr == NULL) {
            validateSignature("SEXP(*os_logpost_xptr)(std::string)");
            p_os_logpost_xptr = (Ptr_os_logpost_xptr)R_GetCCallable("revdbayes", "_revdbayes_os_logpost_xptr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_logpost_xptr(Shield<SEXP>(Rcpp::wrap(fstr)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<SEXP >(rcpp_result_gen);
    }

    inline SEXP pp_logpost_xptr(std::string fstr) {
        typedef SEXP(*Ptr_pp_logpost_xptr)(SEXP);
        static Ptr_pp_logpost_xptr p_pp_logpost_xptr = NULL;
        if (p_pp_logpost_xptr == NULL) {
            validateSignature("SEXP(*pp_logpost_xptr)(std::string)");
            p_pp_logpost_xptr = (Ptr_pp_logpost_xptr)R_GetCCallable("revdbayes", "_revdbayes_pp_logpost_xptr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_logpost_xptr(Shield<SEXP>(Rcpp::wrap(fstr)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<SEXP >(rcpp_result_gen);
    }

    inline Rcpp::NumericVector gp_phi_to_theta(const Rcpp::NumericVector& phi, const Rcpp::List& user_args) {
        typedef SEXP(*Ptr_gp_phi_to_theta)(SEXP,SEXP);
        static Ptr_gp_phi_to_theta p_gp_phi_to_theta = NULL;
        if (p_gp_phi_to_theta == NULL) {
            validateSignature("Rcpp::NumericVector(*gp_phi_to_theta)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_phi_to_theta = (Ptr_gp_phi_to_theta)R_GetCCallable("revdbayes", "_revdbayes_gp_phi_to_theta");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_phi_to_theta(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(user_args)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<Rcpp::NumericVector >(rcpp_result_gen);
    }

    inline Rcpp::NumericVector gev_phi_to_theta(const Rcpp::NumericVector& phi, const Rcpp::List& user_args) {
        typedef SEXP(*Ptr_gev_phi_to_theta)(SEXP,SEXP);
        static Ptr_gev_phi_to_theta p_gev_phi_to_theta = NULL;
        if (p_gev_phi_to_theta == NULL) {
            validateSignature("Rcpp::NumericVector(*gev_phi_to_theta)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_phi_to_theta = (Ptr_gev_phi_to_theta)R_GetCCallable("revdbayes", "_revdbayes_gev_phi_to_theta");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_phi_to_theta(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(user_args)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<Rcpp::NumericVector >(rcpp_result_gen);
    }

    inline Rcpp::NumericVector pp_phi_to_theta(const Rcpp::NumericVector& phi, const Rcpp::List& user_args) {
        typedef SEXP(*Ptr_pp_phi_to_theta)(SEXP,SEXP);
        static Ptr_pp_phi_to_theta p_pp_phi_to_theta = NULL;
        if (p_pp_phi_to_theta == NULL) {
            validateSignature("Rcpp::NumericVector(*pp_phi_to_theta)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_phi_to_theta = (Ptr_pp_phi_to_theta)R_GetCCallable("revdbayes", "_revdbayes_pp_phi_to_theta");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_phi_to_theta(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(user_args)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<Rcpp::NumericVector >(rcpp_result_gen);
    }

    inline Rcpp::NumericVector kgaps_phi_to_theta(const Rcpp::NumericVector& phi, const Rcpp::List& user_args) {
        typedef SEXP(*Ptr_kgaps_phi_to_theta)(SEXP,SEXP);
        static Ptr_kgaps_phi_to_theta p_kgaps_phi_to_theta = NULL;
        if (p_kgaps_phi_to_theta == NULL) {
            validateSignature("Rcpp::NumericVector(*kgaps_phi_to_theta)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_kgaps_phi_to_theta = (Ptr_kgaps_phi_to_theta)R_GetCCallable("revdbayes", "_revdbayes_kgaps_phi_to_theta");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_kgaps_phi_to_theta(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(user_args)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<Rcpp::NumericVector >(rcpp_result_gen);
    }

    inline SEXP phi_to_theta_xptr(std::string fstr) {
        typedef SEXP(*Ptr_phi_to_theta_xptr)(SEXP);
        static Ptr_phi_to_theta_xptr p_phi_to_theta_xptr = NULL;
        if (p_phi_to_theta_xptr == NULL) {
            validateSignature("SEXP(*phi_to_theta_xptr)(std::string)");
            p_phi_to_theta_xptr = (Ptr_phi_to_theta_xptr)R_GetCCallable("revdbayes", "_revdbayes_phi_to_theta_xptr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_phi_to_theta_xptr(Shield<SEXP>(Rcpp::wrap(fstr)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<SEXP >(rcpp_result_gen);
    }

    inline double gp_mdi_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_mdi_logpost_phi)(SEXP,SEXP);
        static Ptr_gp_mdi_logpost_phi p_gp_mdi_logpost_phi = NULL;
        if (p_gp_mdi_logpost_phi == NULL) {
            validateSignature("double(*gp_mdi_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_mdi_logpost_phi = (Ptr_gp_mdi_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gp_mdi_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_mdi_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gp_norm_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_norm_logpost_phi)(SEXP,SEXP);
        static Ptr_gp_norm_logpost_phi p_gp_norm_logpost_phi = NULL;
        if (p_gp_norm_logpost_phi == NULL) {
            validateSignature("double(*gp_norm_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_norm_logpost_phi = (Ptr_gp_norm_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gp_norm_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_norm_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gp_flat_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_flat_logpost_phi)(SEXP,SEXP);
        static Ptr_gp_flat_logpost_phi p_gp_flat_logpost_phi = NULL;
        if (p_gp_flat_logpost_phi == NULL) {
            validateSignature("double(*gp_flat_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_flat_logpost_phi = (Ptr_gp_flat_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gp_flat_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_flat_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gp_flatflat_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_flatflat_logpost_phi)(SEXP,SEXP);
        static Ptr_gp_flatflat_logpost_phi p_gp_flatflat_logpost_phi = NULL;
        if (p_gp_flatflat_logpost_phi == NULL) {
            validateSignature("double(*gp_flatflat_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_flatflat_logpost_phi = (Ptr_gp_flatflat_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gp_flatflat_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_flatflat_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gp_jeffreys_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_jeffreys_logpost_phi)(SEXP,SEXP);
        static Ptr_gp_jeffreys_logpost_phi p_gp_jeffreys_logpost_phi = NULL;
        if (p_gp_jeffreys_logpost_phi == NULL) {
            validateSignature("double(*gp_jeffreys_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_jeffreys_logpost_phi = (Ptr_gp_jeffreys_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gp_jeffreys_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_jeffreys_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gp_beta_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_beta_logpost_phi)(SEXP,SEXP);
        static Ptr_gp_beta_logpost_phi p_gp_beta_logpost_phi = NULL;
        if (p_gp_beta_logpost_phi == NULL) {
            validateSignature("double(*gp_beta_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_beta_logpost_phi = (Ptr_gp_beta_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gp_beta_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_beta_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gp_user_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gp_user_logpost_phi)(SEXP,SEXP);
        static Ptr_gp_user_logpost_phi p_gp_user_logpost_phi = NULL;
        if (p_gp_user_logpost_phi == NULL) {
            validateSignature("double(*gp_user_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gp_user_logpost_phi = (Ptr_gp_user_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gp_user_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_user_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_mdi_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_mdi_logpost_phi)(SEXP,SEXP);
        static Ptr_gev_mdi_logpost_phi p_gev_mdi_logpost_phi = NULL;
        if (p_gev_mdi_logpost_phi == NULL) {
            validateSignature("double(*gev_mdi_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_mdi_logpost_phi = (Ptr_gev_mdi_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gev_mdi_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_mdi_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_norm_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_norm_logpost_phi)(SEXP,SEXP);
        static Ptr_gev_norm_logpost_phi p_gev_norm_logpost_phi = NULL;
        if (p_gev_norm_logpost_phi == NULL) {
            validateSignature("double(*gev_norm_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_norm_logpost_phi = (Ptr_gev_norm_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gev_norm_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_norm_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_loglognorm_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_loglognorm_logpost_phi)(SEXP,SEXP);
        static Ptr_gev_loglognorm_logpost_phi p_gev_loglognorm_logpost_phi = NULL;
        if (p_gev_loglognorm_logpost_phi == NULL) {
            validateSignature("double(*gev_loglognorm_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_loglognorm_logpost_phi = (Ptr_gev_loglognorm_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gev_loglognorm_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_loglognorm_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_flat_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_flat_logpost_phi)(SEXP,SEXP);
        static Ptr_gev_flat_logpost_phi p_gev_flat_logpost_phi = NULL;
        if (p_gev_flat_logpost_phi == NULL) {
            validateSignature("double(*gev_flat_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_flat_logpost_phi = (Ptr_gev_flat_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gev_flat_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_flat_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_flatflat_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_flatflat_logpost_phi)(SEXP,SEXP);
        static Ptr_gev_flatflat_logpost_phi p_gev_flatflat_logpost_phi = NULL;
        if (p_gev_flatflat_logpost_phi == NULL) {
            validateSignature("double(*gev_flatflat_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_flatflat_logpost_phi = (Ptr_gev_flatflat_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gev_flatflat_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_flatflat_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_beta_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_beta_logpost_phi)(SEXP,SEXP);
        static Ptr_gev_beta_logpost_phi p_gev_beta_logpost_phi = NULL;
        if (p_gev_beta_logpost_phi == NULL) {
            validateSignature("double(*gev_beta_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_beta_logpost_phi = (Ptr_gev_beta_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gev_beta_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_beta_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_prob_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_prob_logpost_phi)(SEXP,SEXP);
        static Ptr_gev_prob_logpost_phi p_gev_prob_logpost_phi = NULL;
        if (p_gev_prob_logpost_phi == NULL) {
            validateSignature("double(*gev_prob_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_prob_logpost_phi = (Ptr_gev_prob_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gev_prob_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_prob_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_quant_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_quant_logpost_phi)(SEXP,SEXP);
        static Ptr_gev_quant_logpost_phi p_gev_quant_logpost_phi = NULL;
        if (p_gev_quant_logpost_phi == NULL) {
            validateSignature("double(*gev_quant_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_quant_logpost_phi = (Ptr_gev_quant_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gev_quant_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_quant_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double gev_user_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_gev_user_logpost_phi)(SEXP,SEXP);
        static Ptr_gev_user_logpost_phi p_gev_user_logpost_phi = NULL;
        if (p_gev_user_logpost_phi == NULL) {
            validateSignature("double(*gev_user_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_gev_user_logpost_phi = (Ptr_gev_user_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_gev_user_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_user_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_mdi_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_mdi_logpost_phi)(SEXP,SEXP);
        static Ptr_os_mdi_logpost_phi p_os_mdi_logpost_phi = NULL;
        if (p_os_mdi_logpost_phi == NULL) {
            validateSignature("double(*os_mdi_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_mdi_logpost_phi = (Ptr_os_mdi_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_os_mdi_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_mdi_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_norm_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_norm_logpost_phi)(SEXP,SEXP);
        static Ptr_os_norm_logpost_phi p_os_norm_logpost_phi = NULL;
        if (p_os_norm_logpost_phi == NULL) {
            validateSignature("double(*os_norm_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_norm_logpost_phi = (Ptr_os_norm_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_os_norm_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_norm_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_loglognorm_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_loglognorm_logpost_phi)(SEXP,SEXP);
        static Ptr_os_loglognorm_logpost_phi p_os_loglognorm_logpost_phi = NULL;
        if (p_os_loglognorm_logpost_phi == NULL) {
            validateSignature("double(*os_loglognorm_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_loglognorm_logpost_phi = (Ptr_os_loglognorm_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_os_loglognorm_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_loglognorm_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_flat_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_flat_logpost_phi)(SEXP,SEXP);
        static Ptr_os_flat_logpost_phi p_os_flat_logpost_phi = NULL;
        if (p_os_flat_logpost_phi == NULL) {
            validateSignature("double(*os_flat_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_flat_logpost_phi = (Ptr_os_flat_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_os_flat_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_flat_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_flatflat_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_flatflat_logpost_phi)(SEXP,SEXP);
        static Ptr_os_flatflat_logpost_phi p_os_flatflat_logpost_phi = NULL;
        if (p_os_flatflat_logpost_phi == NULL) {
            validateSignature("double(*os_flatflat_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_flatflat_logpost_phi = (Ptr_os_flatflat_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_os_flatflat_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_flatflat_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_beta_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_beta_logpost_phi)(SEXP,SEXP);
        static Ptr_os_beta_logpost_phi p_os_beta_logpost_phi = NULL;
        if (p_os_beta_logpost_phi == NULL) {
            validateSignature("double(*os_beta_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_beta_logpost_phi = (Ptr_os_beta_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_os_beta_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_beta_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_prob_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_prob_logpost_phi)(SEXP,SEXP);
        static Ptr_os_prob_logpost_phi p_os_prob_logpost_phi = NULL;
        if (p_os_prob_logpost_phi == NULL) {
            validateSignature("double(*os_prob_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_prob_logpost_phi = (Ptr_os_prob_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_os_prob_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_prob_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_quant_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_quant_logpost_phi)(SEXP,SEXP);
        static Ptr_os_quant_logpost_phi p_os_quant_logpost_phi = NULL;
        if (p_os_quant_logpost_phi == NULL) {
            validateSignature("double(*os_quant_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_quant_logpost_phi = (Ptr_os_quant_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_os_quant_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_quant_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double os_user_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_os_user_logpost_phi)(SEXP,SEXP);
        static Ptr_os_user_logpost_phi p_os_user_logpost_phi = NULL;
        if (p_os_user_logpost_phi == NULL) {
            validateSignature("double(*os_user_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_os_user_logpost_phi = (Ptr_os_user_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_os_user_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_user_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_mdi_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_mdi_logpost_phi)(SEXP,SEXP);
        static Ptr_pp_mdi_logpost_phi p_pp_mdi_logpost_phi = NULL;
        if (p_pp_mdi_logpost_phi == NULL) {
            validateSignature("double(*pp_mdi_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_mdi_logpost_phi = (Ptr_pp_mdi_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_pp_mdi_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_mdi_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_norm_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_norm_logpost_phi)(SEXP,SEXP);
        static Ptr_pp_norm_logpost_phi p_pp_norm_logpost_phi = NULL;
        if (p_pp_norm_logpost_phi == NULL) {
            validateSignature("double(*pp_norm_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_norm_logpost_phi = (Ptr_pp_norm_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_pp_norm_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_norm_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_loglognorm_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_loglognorm_logpost_phi)(SEXP,SEXP);
        static Ptr_pp_loglognorm_logpost_phi p_pp_loglognorm_logpost_phi = NULL;
        if (p_pp_loglognorm_logpost_phi == NULL) {
            validateSignature("double(*pp_loglognorm_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_loglognorm_logpost_phi = (Ptr_pp_loglognorm_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_pp_loglognorm_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_loglognorm_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_flat_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_flat_logpost_phi)(SEXP,SEXP);
        static Ptr_pp_flat_logpost_phi p_pp_flat_logpost_phi = NULL;
        if (p_pp_flat_logpost_phi == NULL) {
            validateSignature("double(*pp_flat_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_flat_logpost_phi = (Ptr_pp_flat_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_pp_flat_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_flat_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_flatflat_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_flatflat_logpost_phi)(SEXP,SEXP);
        static Ptr_pp_flatflat_logpost_phi p_pp_flatflat_logpost_phi = NULL;
        if (p_pp_flatflat_logpost_phi == NULL) {
            validateSignature("double(*pp_flatflat_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_flatflat_logpost_phi = (Ptr_pp_flatflat_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_pp_flatflat_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_flatflat_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_beta_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_beta_logpost_phi)(SEXP,SEXP);
        static Ptr_pp_beta_logpost_phi p_pp_beta_logpost_phi = NULL;
        if (p_pp_beta_logpost_phi == NULL) {
            validateSignature("double(*pp_beta_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_beta_logpost_phi = (Ptr_pp_beta_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_pp_beta_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_beta_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_prob_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_prob_logpost_phi)(SEXP,SEXP);
        static Ptr_pp_prob_logpost_phi p_pp_prob_logpost_phi = NULL;
        if (p_pp_prob_logpost_phi == NULL) {
            validateSignature("double(*pp_prob_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_prob_logpost_phi = (Ptr_pp_prob_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_pp_prob_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_prob_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_quant_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_quant_logpost_phi)(SEXP,SEXP);
        static Ptr_pp_quant_logpost_phi p_pp_quant_logpost_phi = NULL;
        if (p_pp_quant_logpost_phi == NULL) {
            validateSignature("double(*pp_quant_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_quant_logpost_phi = (Ptr_pp_quant_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_pp_quant_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_quant_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double pp_user_logpost_phi(const Rcpp::NumericVector& phi, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_pp_user_logpost_phi)(SEXP,SEXP);
        static Ptr_pp_user_logpost_phi p_pp_user_logpost_phi = NULL;
        if (p_pp_user_logpost_phi == NULL) {
            validateSignature("double(*pp_user_logpost_phi)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_pp_user_logpost_phi = (Ptr_pp_user_logpost_phi)R_GetCCallable("revdbayes", "_revdbayes_pp_user_logpost_phi");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_user_logpost_phi(Shield<SEXP>(Rcpp::wrap(phi)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline SEXP gp_logpost_phi_xptr(std::string fstr) {
        typedef SEXP(*Ptr_gp_logpost_phi_xptr)(SEXP);
        static Ptr_gp_logpost_phi_xptr p_gp_logpost_phi_xptr = NULL;
        if (p_gp_logpost_phi_xptr == NULL) {
            validateSignature("SEXP(*gp_logpost_phi_xptr)(std::string)");
            p_gp_logpost_phi_xptr = (Ptr_gp_logpost_phi_xptr)R_GetCCallable("revdbayes", "_revdbayes_gp_logpost_phi_xptr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gp_logpost_phi_xptr(Shield<SEXP>(Rcpp::wrap(fstr)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<SEXP >(rcpp_result_gen);
    }

    inline SEXP gev_logpost_phi_xptr(std::string fstr) {
        typedef SEXP(*Ptr_gev_logpost_phi_xptr)(SEXP);
        static Ptr_gev_logpost_phi_xptr p_gev_logpost_phi_xptr = NULL;
        if (p_gev_logpost_phi_xptr == NULL) {
            validateSignature("SEXP(*gev_logpost_phi_xptr)(std::string)");
            p_gev_logpost_phi_xptr = (Ptr_gev_logpost_phi_xptr)R_GetCCallable("revdbayes", "_revdbayes_gev_logpost_phi_xptr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_gev_logpost_phi_xptr(Shield<SEXP>(Rcpp::wrap(fstr)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<SEXP >(rcpp_result_gen);
    }

    inline SEXP pp_logpost_phi_xptr(std::string fstr) {
        typedef SEXP(*Ptr_pp_logpost_phi_xptr)(SEXP);
        static Ptr_pp_logpost_phi_xptr p_pp_logpost_phi_xptr = NULL;
        if (p_pp_logpost_phi_xptr == NULL) {
            validateSignature("SEXP(*pp_logpost_phi_xptr)(std::string)");
            p_pp_logpost_phi_xptr = (Ptr_pp_logpost_phi_xptr)R_GetCCallable("revdbayes", "_revdbayes_pp_logpost_phi_xptr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_pp_logpost_phi_xptr(Shield<SEXP>(Rcpp::wrap(fstr)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<SEXP >(rcpp_result_gen);
    }

    inline SEXP os_logpost_phi_xptr(std::string fstr) {
        typedef SEXP(*Ptr_os_logpost_phi_xptr)(SEXP);
        static Ptr_os_logpost_phi_xptr p_os_logpost_phi_xptr = NULL;
        if (p_os_logpost_phi_xptr == NULL) {
            validateSignature("SEXP(*os_logpost_phi_xptr)(std::string)");
            p_os_logpost_phi_xptr = (Ptr_os_logpost_phi_xptr)R_GetCCallable("revdbayes", "_revdbayes_os_logpost_phi_xptr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_os_logpost_phi_xptr(Shield<SEXP>(Rcpp::wrap(fstr)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<SEXP >(rcpp_result_gen);
    }

    inline double kgaps_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_kgaps_logpost)(SEXP,SEXP);
        static Ptr_kgaps_logpost p_kgaps_logpost = NULL;
        if (p_kgaps_logpost == NULL) {
            validateSignature("double(*kgaps_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_kgaps_logpost = (Ptr_kgaps_logpost)R_GetCCallable("revdbayes", "_revdbayes_kgaps_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_kgaps_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double dgaps_logpost(const Rcpp::NumericVector& x, const Rcpp::List& pars) {
        typedef SEXP(*Ptr_dgaps_logpost)(SEXP,SEXP);
        static Ptr_dgaps_logpost p_dgaps_logpost = NULL;
        if (p_dgaps_logpost == NULL) {
            validateSignature("double(*dgaps_logpost)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_dgaps_logpost = (Ptr_dgaps_logpost)R_GetCCallable("revdbayes", "_revdbayes_dgaps_logpost");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_dgaps_logpost(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(pars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline SEXP kgaps_logpost_xptr(std::string fstr) {
        typedef SEXP(*Ptr_kgaps_logpost_xptr)(SEXP);
        static Ptr_kgaps_logpost_xptr p_kgaps_logpost_xptr = NULL;
        if (p_kgaps_logpost_xptr == NULL) {
            validateSignature("SEXP(*kgaps_logpost_xptr)(std::string)");
            p_kgaps_logpost_xptr = (Ptr_kgaps_logpost_xptr)R_GetCCallable("revdbayes", "_revdbayes_kgaps_logpost_xptr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_kgaps_logpost_xptr(Shield<SEXP>(Rcpp::wrap(fstr)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<SEXP >(rcpp_result_gen);
    }

    inline double kgaps_log_j(const Rcpp::NumericVector& theta, const Rcpp::List& user_args) {
        typedef SEXP(*Ptr_kgaps_log_j)(SEXP,SEXP);
        static Ptr_kgaps_log_j p_kgaps_log_j = NULL;
        if (p_kgaps_log_j == NULL) {
            validateSignature("double(*kgaps_log_j)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_kgaps_log_j = (Ptr_kgaps_log_j)R_GetCCallable("revdbayes", "_revdbayes_kgaps_log_j");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_kgaps_log_j(Shield<SEXP>(Rcpp::wrap(theta)), Shield<SEXP>(Rcpp::wrap(user_args)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline SEXP log_j_xptr(std::string fstr) {
        typedef SEXP(*Ptr_log_j_xptr)(SEXP);
        static Ptr_log_j_xptr p_log_j_xptr = NULL;
        if (p_log_j_xptr == NULL) {
            validateSignature("SEXP(*log_j_xptr)(std::string)");
            p_log_j_xptr = (Ptr_log_j_xptr)R_GetCCallable("revdbayes", "_revdbayes_log_j_xptr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_log_j_xptr(Shield<SEXP>(Rcpp::wrap(fstr)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<SEXP >(rcpp_result_gen);
    }

    inline double user_gp_flat(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_user_gp_flat)(SEXP,SEXP);
        static Ptr_user_gp_flat p_user_gp_flat = NULL;
        if (p_user_gp_flat == NULL) {
            validateSignature("double(*user_gp_flat)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_user_gp_flat = (Ptr_user_gp_flat)R_GetCCallable("revdbayes", "_revdbayes_user_gp_flat");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_user_gp_flat(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double user_gev_norm(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_user_gev_norm)(SEXP,SEXP);
        static Ptr_user_gev_norm p_user_gev_norm = NULL;
        if (p_user_gev_norm == NULL) {
            validateSignature("double(*user_gev_norm)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_user_gev_norm = (Ptr_user_gev_norm)R_GetCCallable("revdbayes", "_revdbayes_user_gev_norm");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_user_gev_norm(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline double user_gev_flat(const Rcpp::NumericVector& x, const Rcpp::List& ppars) {
        typedef SEXP(*Ptr_user_gev_flat)(SEXP,SEXP);
        static Ptr_user_gev_flat p_user_gev_flat = NULL;
        if (p_user_gev_flat == NULL) {
            validateSignature("double(*user_gev_flat)(const Rcpp::NumericVector&,const Rcpp::List&)");
            p_user_gev_flat = (Ptr_user_gev_flat)R_GetCCallable("revdbayes", "_revdbayes_user_gev_flat");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_user_gev_flat(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(ppars)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<double >(rcpp_result_gen);
    }

    inline SEXP create_prior_xptr(std::string fstr) {
        typedef SEXP(*Ptr_create_prior_xptr)(SEXP);
        static Ptr_create_prior_xptr p_create_prior_xptr = NULL;
        if (p_create_prior_xptr == NULL) {
            validateSignature("SEXP(*create_prior_xptr)(std::string)");
            p_create_prior_xptr = (Ptr_create_prior_xptr)R_GetCCallable("revdbayes", "_revdbayes_create_prior_xptr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_create_prior_xptr(Shield<SEXP>(Rcpp::wrap(fstr)));
        }
        if (rcpp_result_gen.inherits("interrupted-error"))
            throw Rcpp::internal::InterruptedException();
        if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen))
            throw Rcpp::LongjumpException(rcpp_result_gen);
        if (rcpp_result_gen.inherits("try-error"))
            throw Rcpp::exception(Rcpp::as<std::string>(rcpp_result_gen).c_str());
        return Rcpp::as<SEXP >(rcpp_result_gen);
    }

}

#endif // RCPP_revdbayes_RCPPEXPORTS_H_GEN_
