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

#ifndef RCPP_mnorm_RCPPEXPORTS_H_GEN_
#define RCPP_mnorm_RCPPEXPORTS_H_GEN_

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

namespace mnorm {

    using namespace Rcpp;

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

    inline List cmnorm(const NumericVector mean, const NumericMatrix sigma, const NumericVector given_ind, const NumericVector given_x, NumericVector dependent_ind = NumericVector(), const bool is_validation = true, const bool is_names = true, Nullable<List> control = R_NilValue, const int n_cores = 1) {
        typedef SEXP(*Ptr_cmnorm)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
        static Ptr_cmnorm p_cmnorm = NULL;
        if (p_cmnorm == NULL) {
            validateSignature("List(*cmnorm)(const NumericVector,const NumericMatrix,const NumericVector,const NumericVector,NumericVector,const bool,const bool,Nullable<List>,const int)");
            p_cmnorm = (Ptr_cmnorm)R_GetCCallable("mnorm", "_mnorm_cmnorm");
        }
        RObject rcpp_result_gen;
        {
            rcpp_result_gen = p_cmnorm(Shield<SEXP>(Rcpp::wrap(mean)), Shield<SEXP>(Rcpp::wrap(sigma)), Shield<SEXP>(Rcpp::wrap(given_ind)), Shield<SEXP>(Rcpp::wrap(given_x)), Shield<SEXP>(Rcpp::wrap(dependent_ind)), Shield<SEXP>(Rcpp::wrap(is_validation)), Shield<SEXP>(Rcpp::wrap(is_names)), Shield<SEXP>(Rcpp::wrap(control)), Shield<SEXP>(Rcpp::wrap(n_cores)));
        }
        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<List >(rcpp_result_gen);
    }

    inline List dmnorm(const NumericVector x, const NumericVector mean, const NumericMatrix sigma, const NumericVector given_ind = NumericVector(), const bool log = false, const bool grad_x = false, const bool grad_sigma = false, const bool is_validation = true, const Nullable<List> control = R_NilValue, const int n_cores = 1) {
        typedef SEXP(*Ptr_dmnorm)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
        static Ptr_dmnorm p_dmnorm = NULL;
        if (p_dmnorm == NULL) {
            validateSignature("List(*dmnorm)(const NumericVector,const NumericVector,const NumericMatrix,const NumericVector,const bool,const bool,const bool,const bool,const Nullable<List>,const int)");
            p_dmnorm = (Ptr_dmnorm)R_GetCCallable("mnorm", "_mnorm_dmnorm");
        }
        RObject rcpp_result_gen;
        {
            rcpp_result_gen = p_dmnorm(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(mean)), Shield<SEXP>(Rcpp::wrap(sigma)), Shield<SEXP>(Rcpp::wrap(given_ind)), Shield<SEXP>(Rcpp::wrap(log)), Shield<SEXP>(Rcpp::wrap(grad_x)), Shield<SEXP>(Rcpp::wrap(grad_sigma)), Shield<SEXP>(Rcpp::wrap(is_validation)), Shield<SEXP>(Rcpp::wrap(control)), Shield<SEXP>(Rcpp::wrap(n_cores)));
        }
        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<List >(rcpp_result_gen);
    }

    inline NumericMatrix halton(const int n = 1, const IntegerVector base = IntegerVector::create(2), const int start = 1, const String random = "NO", const String type = "halton", const String scrambler = "NO", const bool is_validation = true, const int n_cores = 1) {
        typedef SEXP(*Ptr_halton)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
        static Ptr_halton p_halton = NULL;
        if (p_halton == NULL) {
            validateSignature("NumericMatrix(*halton)(const int,const IntegerVector,const int,const String,const String,const String,const bool,const int)");
            p_halton = (Ptr_halton)R_GetCCallable("mnorm", "_mnorm_halton");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_halton(Shield<SEXP>(Rcpp::wrap(n)), Shield<SEXP>(Rcpp::wrap(base)), Shield<SEXP>(Rcpp::wrap(start)), Shield<SEXP>(Rcpp::wrap(random)), Shield<SEXP>(Rcpp::wrap(type)), Shield<SEXP>(Rcpp::wrap(scrambler)), Shield<SEXP>(Rcpp::wrap(is_validation)), Shield<SEXP>(Rcpp::wrap(n_cores)));
        }
        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<NumericMatrix >(rcpp_result_gen);
    }

    inline double haltonSingleDraw(int ind = 1, int base = 2, const String scrambler = "NO") {
        typedef SEXP(*Ptr_haltonSingleDraw)(SEXP,SEXP,SEXP);
        static Ptr_haltonSingleDraw p_haltonSingleDraw = NULL;
        if (p_haltonSingleDraw == NULL) {
            validateSignature("double(*haltonSingleDraw)(int,int,const String)");
            p_haltonSingleDraw = (Ptr_haltonSingleDraw)R_GetCCallable("mnorm", "_mnorm_haltonSingleDraw");
        }
        RObject rcpp_result_gen;
        {
            rcpp_result_gen = p_haltonSingleDraw(Shield<SEXP>(Rcpp::wrap(ind)), Shield<SEXP>(Rcpp::wrap(base)), Shield<SEXP>(Rcpp::wrap(scrambler)));
        }
        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 IntegerVector seqPrimes(const int n) {
        typedef SEXP(*Ptr_seqPrimes)(SEXP);
        static Ptr_seqPrimes p_seqPrimes = NULL;
        if (p_seqPrimes == NULL) {
            validateSignature("IntegerVector(*seqPrimes)(const int)");
            p_seqPrimes = (Ptr_seqPrimes)R_GetCCallable("mnorm", "_mnorm_seqPrimes");
        }
        RObject rcpp_result_gen;
        {
            rcpp_result_gen = p_seqPrimes(Shield<SEXP>(Rcpp::wrap(n)));
        }
        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<IntegerVector >(rcpp_result_gen);
    }

    inline IntegerVector toBase(int x, const int base = 2) {
        typedef SEXP(*Ptr_toBase)(SEXP,SEXP);
        static Ptr_toBase p_toBase = NULL;
        if (p_toBase == NULL) {
            validateSignature("IntegerVector(*toBase)(int,const int)");
            p_toBase = (Ptr_toBase)R_GetCCallable("mnorm", "_mnorm_toBase");
        }
        RObject rcpp_result_gen;
        {
            rcpp_result_gen = p_toBase(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(base)));
        }
        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<IntegerVector >(rcpp_result_gen);
    }

    inline double fromBase(const IntegerVector x, const int base = 2) {
        typedef SEXP(*Ptr_fromBase)(SEXP,SEXP);
        static Ptr_fromBase p_fromBase = NULL;
        if (p_fromBase == NULL) {
            validateSignature("double(*fromBase)(const IntegerVector,const int)");
            p_fromBase = (Ptr_fromBase)R_GetCCallable("mnorm", "_mnorm_fromBase");
        }
        RObject rcpp_result_gen;
        {
            rcpp_result_gen = p_fromBase(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(base)));
        }
        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 List pmnorm(const NumericVector lower, const NumericVector upper, const NumericVector given_x = NumericVector(), const NumericVector mean = NumericVector(), const NumericMatrix sigma = NumericMatrix(), const NumericVector given_ind = NumericVector(), const int n_sim = 1000, const String method = "default", const String ordering = "mean", const bool log = false, const bool grad_lower = false, const bool grad_upper = false, const bool grad_sigma = false, const bool grad_given = false, const bool is_validation = true, const Nullable<List> control = R_NilValue, const int n_cores = 1, const Nullable<List> marginal = R_NilValue, const bool grad_marginal = false, const bool grad_marginal_prob = false) {
        typedef SEXP(*Ptr_pmnorm)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
        static Ptr_pmnorm p_pmnorm = NULL;
        if (p_pmnorm == NULL) {
            validateSignature("List(*pmnorm)(const NumericVector,const NumericVector,const NumericVector,const NumericVector,const NumericMatrix,const NumericVector,const int,const String,const String,const bool,const bool,const bool,const bool,const bool,const bool,const Nullable<List>,const int,const Nullable<List>,const bool,const bool)");
            p_pmnorm = (Ptr_pmnorm)R_GetCCallable("mnorm", "_mnorm_pmnorm");
        }
        RObject rcpp_result_gen;
        {
            rcpp_result_gen = p_pmnorm(Shield<SEXP>(Rcpp::wrap(lower)), Shield<SEXP>(Rcpp::wrap(upper)), Shield<SEXP>(Rcpp::wrap(given_x)), Shield<SEXP>(Rcpp::wrap(mean)), Shield<SEXP>(Rcpp::wrap(sigma)), Shield<SEXP>(Rcpp::wrap(given_ind)), Shield<SEXP>(Rcpp::wrap(n_sim)), Shield<SEXP>(Rcpp::wrap(method)), Shield<SEXP>(Rcpp::wrap(ordering)), Shield<SEXP>(Rcpp::wrap(log)), Shield<SEXP>(Rcpp::wrap(grad_lower)), Shield<SEXP>(Rcpp::wrap(grad_upper)), Shield<SEXP>(Rcpp::wrap(grad_sigma)), Shield<SEXP>(Rcpp::wrap(grad_given)), Shield<SEXP>(Rcpp::wrap(is_validation)), Shield<SEXP>(Rcpp::wrap(control)), Shield<SEXP>(Rcpp::wrap(n_cores)), Shield<SEXP>(Rcpp::wrap(marginal)), Shield<SEXP>(Rcpp::wrap(grad_marginal)), Shield<SEXP>(Rcpp::wrap(grad_marginal_prob)));
        }
        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<List >(rcpp_result_gen);
    }

    inline double GHK(const NumericVector lower, const NumericVector upper, const NumericMatrix sigma, const arma::mat h, const String ordering = "default", const int n_sim = 1000, const int n_cores = 1) {
        typedef SEXP(*Ptr_GHK)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
        static Ptr_GHK p_GHK = NULL;
        if (p_GHK == NULL) {
            validateSignature("double(*GHK)(const NumericVector,const NumericVector,const NumericMatrix,const arma::mat,const String,const int,const int)");
            p_GHK = (Ptr_GHK)R_GetCCallable("mnorm", "_mnorm_GHK");
        }
        RObject rcpp_result_gen;
        {
            rcpp_result_gen = p_GHK(Shield<SEXP>(Rcpp::wrap(lower)), Shield<SEXP>(Rcpp::wrap(upper)), Shield<SEXP>(Rcpp::wrap(sigma)), Shield<SEXP>(Rcpp::wrap(h)), Shield<SEXP>(Rcpp::wrap(ordering)), Shield<SEXP>(Rcpp::wrap(n_sim)), Shield<SEXP>(Rcpp::wrap(n_cores)));
        }
        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 arma::vec qnormFast(arma::vec const& p, const double mean = 0, const int sd = 1, String method = "Voutier", bool is_validation = true, const int n_cores = 1) {
        typedef SEXP(*Ptr_qnormFast)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
        static Ptr_qnormFast p_qnormFast = NULL;
        if (p_qnormFast == NULL) {
            validateSignature("arma::vec(*qnormFast)(arma::vec const&,const double,const int,String,bool,const int)");
            p_qnormFast = (Ptr_qnormFast)R_GetCCallable("mnorm", "_mnorm_qnormFast");
        }
        RObject rcpp_result_gen;
        {
            rcpp_result_gen = p_qnormFast(Shield<SEXP>(Rcpp::wrap(p)), Shield<SEXP>(Rcpp::wrap(mean)), Shield<SEXP>(Rcpp::wrap(sd)), Shield<SEXP>(Rcpp::wrap(method)), Shield<SEXP>(Rcpp::wrap(is_validation)), Shield<SEXP>(Rcpp::wrap(n_cores)));
        }
        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<arma::vec >(rcpp_result_gen);
    }

    inline NumericMatrix rmnorm(const int n, const NumericVector mean, const NumericMatrix sigma, const NumericVector given_ind = NumericVector(), const NumericVector given_x = NumericVector(), const NumericVector dependent_ind = NumericVector(), const bool is_validation = true, const int n_cores = 1) {
        typedef SEXP(*Ptr_rmnorm)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
        static Ptr_rmnorm p_rmnorm = NULL;
        if (p_rmnorm == NULL) {
            validateSignature("NumericMatrix(*rmnorm)(const int,const NumericVector,const NumericMatrix,const NumericVector,const NumericVector,const NumericVector,const bool,const int)");
            p_rmnorm = (Ptr_rmnorm)R_GetCCallable("mnorm", "_mnorm_rmnorm");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_rmnorm(Shield<SEXP>(Rcpp::wrap(n)), Shield<SEXP>(Rcpp::wrap(mean)), Shield<SEXP>(Rcpp::wrap(sigma)), Shield<SEXP>(Rcpp::wrap(given_ind)), Shield<SEXP>(Rcpp::wrap(given_x)), Shield<SEXP>(Rcpp::wrap(dependent_ind)), Shield<SEXP>(Rcpp::wrap(is_validation)), Shield<SEXP>(Rcpp::wrap(n_cores)));
        }
        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<NumericMatrix >(rcpp_result_gen);
    }

    inline List pbetaDiff(const arma::vec x, const double p = 10, const double q = 0.5, const int n = 10, const bool is_validation = true, const Nullable<List> control = R_NilValue) {
        typedef SEXP(*Ptr_pbetaDiff)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
        static Ptr_pbetaDiff p_pbetaDiff = NULL;
        if (p_pbetaDiff == NULL) {
            validateSignature("List(*pbetaDiff)(const arma::vec,const double,const double,const int,const bool,const Nullable<List>)");
            p_pbetaDiff = (Ptr_pbetaDiff)R_GetCCallable("mnorm", "_mnorm_pbetaDiff");
        }
        RObject rcpp_result_gen;
        {
            rcpp_result_gen = p_pbetaDiff(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(p)), Shield<SEXP>(Rcpp::wrap(q)), Shield<SEXP>(Rcpp::wrap(n)), Shield<SEXP>(Rcpp::wrap(is_validation)), Shield<SEXP>(Rcpp::wrap(control)));
        }
        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<List >(rcpp_result_gen);
    }

    inline List dt0(const arma::vec x, const double df = 10, const bool log = false, const bool grad_x = false, const bool grad_df = false) {
        typedef SEXP(*Ptr_dt0)(SEXP,SEXP,SEXP,SEXP,SEXP);
        static Ptr_dt0 p_dt0 = NULL;
        if (p_dt0 == NULL) {
            validateSignature("List(*dt0)(const arma::vec,const double,const bool,const bool,const bool)");
            p_dt0 = (Ptr_dt0)R_GetCCallable("mnorm", "_mnorm_dt0");
        }
        RObject rcpp_result_gen;
        {
            rcpp_result_gen = p_dt0(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(df)), Shield<SEXP>(Rcpp::wrap(log)), Shield<SEXP>(Rcpp::wrap(grad_x)), Shield<SEXP>(Rcpp::wrap(grad_df)));
        }
        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<List >(rcpp_result_gen);
    }

    inline List pt0(const arma::vec x, const double df = 10, const bool log = false, const bool grad_x = false, const bool grad_df = false, const int n = 10) {
        typedef SEXP(*Ptr_pt0)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
        static Ptr_pt0 p_pt0 = NULL;
        if (p_pt0 == NULL) {
            validateSignature("List(*pt0)(const arma::vec,const double,const bool,const bool,const bool,const int)");
            p_pt0 = (Ptr_pt0)R_GetCCallable("mnorm", "_mnorm_pt0");
        }
        RObject rcpp_result_gen;
        {
            rcpp_result_gen = p_pt0(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(df)), Shield<SEXP>(Rcpp::wrap(log)), Shield<SEXP>(Rcpp::wrap(grad_x)), Shield<SEXP>(Rcpp::wrap(grad_df)), Shield<SEXP>(Rcpp::wrap(n)));
        }
        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<List >(rcpp_result_gen);
    }

    inline NumericVector rt0(const int n = 1, const double df = 10) {
        typedef SEXP(*Ptr_rt0)(SEXP,SEXP);
        static Ptr_rt0 p_rt0 = NULL;
        if (p_rt0 == NULL) {
            validateSignature("NumericVector(*rt0)(const int,const double)");
            p_rt0 = (Ptr_rt0)R_GetCCallable("mnorm", "_mnorm_rt0");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_rt0(Shield<SEXP>(Rcpp::wrap(n)), Shield<SEXP>(Rcpp::wrap(df)));
        }
        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<NumericVector >(rcpp_result_gen);
    }

    inline NumericVector qt0(const NumericVector x = 1, const double df = 10) {
        typedef SEXP(*Ptr_qt0)(SEXP,SEXP);
        static Ptr_qt0 p_qt0 = NULL;
        if (p_qt0 == NULL) {
            validateSignature("NumericVector(*qt0)(const NumericVector,const double)");
            p_qt0 = (Ptr_qt0)R_GetCCallable("mnorm", "_mnorm_qt0");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_qt0(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(df)));
        }
        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<NumericVector >(rcpp_result_gen);
    }

}

#endif // RCPP_mnorm_RCPPEXPORTS_H_GEN_
