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

#ifndef RCPP_gRbase_RCPPEXPORTS_H_GEN_
#define RCPP_gRbase_RCPPEXPORTS_H_GEN_

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

namespace gRbase {

    using namespace Rcpp;

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

    inline List rip_internal(IntegerVector mcs0idx, CharacterVector vn, List cqlist) {
        typedef SEXP(*Ptr_rip_internal)(SEXP,SEXP,SEXP);
        static Ptr_rip_internal p_rip_internal = NULL;
        if (p_rip_internal == NULL) {
            validateSignature("List(*rip_internal)(IntegerVector,CharacterVector,List)");
            p_rip_internal = (Ptr_rip_internal)R_GetCCallable("gRbase", "_gRbase_rip_internal");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_rip_internal(Shield<SEXP>(Rcpp::wrap(mcs0idx)), Shield<SEXP>(Rcpp::wrap(vn)), Shield<SEXP>(Rcpp::wrap(cqlist)));
        }
        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 SEXP getCliquesDec__(SEXP XX_, SEXP mcs0idx_ = R_NilValue) {
        typedef SEXP(*Ptr_getCliquesDec__)(SEXP,SEXP);
        static Ptr_getCliquesDec__ p_getCliquesDec__ = NULL;
        if (p_getCliquesDec__ == NULL) {
            validateSignature("SEXP(*getCliquesDec__)(SEXP,SEXP)");
            p_getCliquesDec__ = (Ptr_getCliquesDec__)R_GetCCallable("gRbase", "_gRbase_getCliquesDec__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_getCliquesDec__(Shield<SEXP>(Rcpp::wrap(XX_)), Shield<SEXP>(Rcpp::wrap(mcs0idx_)));
        }
        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 int cell2entry_(const NumericVector& cell, const IntegerVector& dim) {
        typedef SEXP(*Ptr_cell2entry_)(SEXP,SEXP);
        static Ptr_cell2entry_ p_cell2entry_ = NULL;
        if (p_cell2entry_ == NULL) {
            validateSignature("int(*cell2entry_)(const NumericVector&,const IntegerVector&)");
            p_cell2entry_ = (Ptr_cell2entry_)R_GetCCallable("gRbase", "_gRbase_cell2entry_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cell2entry_(Shield<SEXP>(Rcpp::wrap(cell)), Shield<SEXP>(Rcpp::wrap(dim)));
        }
        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<int >(rcpp_result_gen);
    }

    inline IntegerVector make_plevels_(const IntegerVector& dim) {
        typedef SEXP(*Ptr_make_plevels_)(SEXP);
        static Ptr_make_plevels_ p_make_plevels_ = NULL;
        if (p_make_plevels_ == NULL) {
            validateSignature("IntegerVector(*make_plevels_)(const IntegerVector&)");
            p_make_plevels_ = (Ptr_make_plevels_)R_GetCCallable("gRbase", "_gRbase_make_plevels_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_make_plevels_(Shield<SEXP>(Rcpp::wrap(dim)));
        }
        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 entry2cell_(const int& entry, const IntegerVector& dim) {
        typedef SEXP(*Ptr_entry2cell_)(SEXP,SEXP);
        static Ptr_entry2cell_ p_entry2cell_ = NULL;
        if (p_entry2cell_ == NULL) {
            validateSignature("IntegerVector(*entry2cell_)(const int&,const IntegerVector&)");
            p_entry2cell_ = (Ptr_entry2cell_)R_GetCCallable("gRbase", "_gRbase_entry2cell_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_entry2cell_(Shield<SEXP>(Rcpp::wrap(entry)), Shield<SEXP>(Rcpp::wrap(dim)));
        }
        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 NumericVector next_cell_(const NumericVector& cell, const IntegerVector& dim) {
        typedef SEXP(*Ptr_next_cell_)(SEXP,SEXP);
        static Ptr_next_cell_ p_next_cell_ = NULL;
        if (p_next_cell_ == NULL) {
            validateSignature("NumericVector(*next_cell_)(const NumericVector&,const IntegerVector&)");
            p_next_cell_ = (Ptr_next_cell_)R_GetCCallable("gRbase", "_gRbase_next_cell_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_next_cell_(Shield<SEXP>(Rcpp::wrap(cell)), Shield<SEXP>(Rcpp::wrap(dim)));
        }
        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 void next_cell2_(IntegerVector& cell, const IntegerVector& dim) {
        typedef SEXP(*Ptr_next_cell2_)(SEXP,SEXP);
        static Ptr_next_cell2_ p_next_cell2_ = NULL;
        if (p_next_cell2_ == NULL) {
            validateSignature("void(*next_cell2_)(IntegerVector&,const IntegerVector&)");
            p_next_cell2_ = (Ptr_next_cell2_)R_GetCCallable("gRbase", "_gRbase_next_cell2_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_next_cell2_(Shield<SEXP>(Rcpp::wrap(cell)), Shield<SEXP>(Rcpp::wrap(dim)));
        }
        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());
    }

    inline NumericVector next_cell_slice_(const NumericVector& cell, const IntegerVector& dim, const IntegerVector& slice_marg) {
        typedef SEXP(*Ptr_next_cell_slice_)(SEXP,SEXP,SEXP);
        static Ptr_next_cell_slice_ p_next_cell_slice_ = NULL;
        if (p_next_cell_slice_ == NULL) {
            validateSignature("NumericVector(*next_cell_slice_)(const NumericVector&,const IntegerVector&,const IntegerVector&)");
            p_next_cell_slice_ = (Ptr_next_cell_slice_)R_GetCCallable("gRbase", "_gRbase_next_cell_slice_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_next_cell_slice_(Shield<SEXP>(Rcpp::wrap(cell)), Shield<SEXP>(Rcpp::wrap(dim)), Shield<SEXP>(Rcpp::wrap(slice_marg)));
        }
        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 IntegerVector slice2entry_(const IntegerVector& slice_cell, const IntegerVector& slice_marg, const IntegerVector& dim) {
        typedef SEXP(*Ptr_slice2entry_)(SEXP,SEXP,SEXP);
        static Ptr_slice2entry_ p_slice2entry_ = NULL;
        if (p_slice2entry_ == NULL) {
            validateSignature("IntegerVector(*slice2entry_)(const IntegerVector&,const IntegerVector&,const IntegerVector&)");
            p_slice2entry_ = (Ptr_slice2entry_)R_GetCCallable("gRbase", "_gRbase_slice2entry_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_slice2entry_(Shield<SEXP>(Rcpp::wrap(slice_cell)), Shield<SEXP>(Rcpp::wrap(slice_marg)), Shield<SEXP>(Rcpp::wrap(dim)));
        }
        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 int cell2entry_perm_(const NumericVector& cell, const IntegerVector& dim, const IntegerVector& perm) {
        typedef SEXP(*Ptr_cell2entry_perm_)(SEXP,SEXP,SEXP);
        static Ptr_cell2entry_perm_ p_cell2entry_perm_ = NULL;
        if (p_cell2entry_perm_ == NULL) {
            validateSignature("int(*cell2entry_perm_)(const NumericVector&,const IntegerVector&,const IntegerVector&)");
            p_cell2entry_perm_ = (Ptr_cell2entry_perm_)R_GetCCallable("gRbase", "_gRbase_cell2entry_perm_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cell2entry_perm_(Shield<SEXP>(Rcpp::wrap(cell)), Shield<SEXP>(Rcpp::wrap(dim)), Shield<SEXP>(Rcpp::wrap(perm)));
        }
        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<int >(rcpp_result_gen);
    }

    inline IntegerVector perm_cell_entries_(const IntegerVector& perm, const IntegerVector& dim) {
        typedef SEXP(*Ptr_perm_cell_entries_)(SEXP,SEXP);
        static Ptr_perm_cell_entries_ p_perm_cell_entries_ = NULL;
        if (p_perm_cell_entries_ == NULL) {
            validateSignature("IntegerVector(*perm_cell_entries_)(const IntegerVector&,const IntegerVector&)");
            p_perm_cell_entries_ = (Ptr_perm_cell_entries_)R_GetCCallable("gRbase", "_gRbase_perm_cell_entries_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_perm_cell_entries_(Shield<SEXP>(Rcpp::wrap(perm)), Shield<SEXP>(Rcpp::wrap(dim)));
        }
        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 SEXP tab_perm_(const SEXP& tab, const SEXP& perm) {
        typedef SEXP(*Ptr_tab_perm_)(SEXP,SEXP);
        static Ptr_tab_perm_ p_tab_perm_ = NULL;
        if (p_tab_perm_ == NULL) {
            validateSignature("SEXP(*tab_perm_)(const SEXP&,const SEXP&)");
            p_tab_perm_ = (Ptr_tab_perm_)R_GetCCallable("gRbase", "_gRbase_tab_perm_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_perm_(Shield<SEXP>(Rcpp::wrap(tab)), Shield<SEXP>(Rcpp::wrap(perm)));
        }
        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 tab_expand_(const SEXP& tab, const SEXP& aux, const int& type = 0) {
        typedef SEXP(*Ptr_tab_expand_)(SEXP,SEXP,SEXP);
        static Ptr_tab_expand_ p_tab_expand_ = NULL;
        if (p_tab_expand_ == NULL) {
            validateSignature("SEXP(*tab_expand_)(const SEXP&,const SEXP&,const int&)");
            p_tab_expand_ = (Ptr_tab_expand_)R_GetCCallable("gRbase", "_gRbase_tab_expand_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_expand_(Shield<SEXP>(Rcpp::wrap(tab)), Shield<SEXP>(Rcpp::wrap(aux)), Shield<SEXP>(Rcpp::wrap(type)));
        }
        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 tab_align_(const SEXP& tab1, const SEXP& tab2) {
        typedef SEXP(*Ptr_tab_align_)(SEXP,SEXP);
        static Ptr_tab_align_ p_tab_align_ = NULL;
        if (p_tab_align_ == NULL) {
            validateSignature("SEXP(*tab_align_)(const SEXP&,const SEXP&)");
            p_tab_align_ = (Ptr_tab_align_)R_GetCCallable("gRbase", "_gRbase_tab_align_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_align_(Shield<SEXP>(Rcpp::wrap(tab1)), Shield<SEXP>(Rcpp::wrap(tab2)));
        }
        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 numVec tab_marg2_(const numVec tab1, const intVec marg) {
        typedef SEXP(*Ptr_tab_marg2_)(SEXP,SEXP);
        static Ptr_tab_marg2_ p_tab_marg2_ = NULL;
        if (p_tab_marg2_ == NULL) {
            validateSignature("numVec(*tab_marg2_)(const numVec,const intVec)");
            p_tab_marg2_ = (Ptr_tab_marg2_)R_GetCCallable("gRbase", "_gRbase_tab_marg2_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_marg2_(Shield<SEXP>(Rcpp::wrap(tab1)), Shield<SEXP>(Rcpp::wrap(marg)));
        }
        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<numVec >(rcpp_result_gen);
    }

    inline SEXP tab_marg_(const SEXP& tab, const SEXP& marg) {
        typedef SEXP(*Ptr_tab_marg_)(SEXP,SEXP);
        static Ptr_tab_marg_ p_tab_marg_ = NULL;
        if (p_tab_marg_ == NULL) {
            validateSignature("SEXP(*tab_marg_)(const SEXP&,const SEXP&)");
            p_tab_marg_ = (Ptr_tab_marg_)R_GetCCallable("gRbase", "_gRbase_tab_marg_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_marg_(Shield<SEXP>(Rcpp::wrap(tab)), Shield<SEXP>(Rcpp::wrap(marg)));
        }
        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 NumericVector tab_op_(const NumericVector& tab1, const NumericVector& tab2, const char op = '*') {
        typedef SEXP(*Ptr_tab_op_)(SEXP,SEXP,SEXP);
        static Ptr_tab_op_ p_tab_op_ = NULL;
        if (p_tab_op_ == NULL) {
            validateSignature("NumericVector(*tab_op_)(const NumericVector&,const NumericVector&,const char)");
            p_tab_op_ = (Ptr_tab_op_)R_GetCCallable("gRbase", "_gRbase_tab_op_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_op_(Shield<SEXP>(Rcpp::wrap(tab1)), Shield<SEXP>(Rcpp::wrap(tab2)), Shield<SEXP>(Rcpp::wrap(op)));
        }
        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 tab_add_(const NumericVector& tab1, const NumericVector& tab2) {
        typedef SEXP(*Ptr_tab_add_)(SEXP,SEXP);
        static Ptr_tab_add_ p_tab_add_ = NULL;
        if (p_tab_add_ == NULL) {
            validateSignature("NumericVector(*tab_add_)(const NumericVector&,const NumericVector&)");
            p_tab_add_ = (Ptr_tab_add_)R_GetCCallable("gRbase", "_gRbase_tab_add_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_add_(Shield<SEXP>(Rcpp::wrap(tab1)), Shield<SEXP>(Rcpp::wrap(tab2)));
        }
        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 tab_subt_(const NumericVector& tab1, const NumericVector& tab2) {
        typedef SEXP(*Ptr_tab_subt_)(SEXP,SEXP);
        static Ptr_tab_subt_ p_tab_subt_ = NULL;
        if (p_tab_subt_ == NULL) {
            validateSignature("NumericVector(*tab_subt_)(const NumericVector&,const NumericVector&)");
            p_tab_subt_ = (Ptr_tab_subt_)R_GetCCallable("gRbase", "_gRbase_tab_subt_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_subt_(Shield<SEXP>(Rcpp::wrap(tab1)), Shield<SEXP>(Rcpp::wrap(tab2)));
        }
        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 tab_mult_(const NumericVector& tab1, const NumericVector& tab2) {
        typedef SEXP(*Ptr_tab_mult_)(SEXP,SEXP);
        static Ptr_tab_mult_ p_tab_mult_ = NULL;
        if (p_tab_mult_ == NULL) {
            validateSignature("NumericVector(*tab_mult_)(const NumericVector&,const NumericVector&)");
            p_tab_mult_ = (Ptr_tab_mult_)R_GetCCallable("gRbase", "_gRbase_tab_mult_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_mult_(Shield<SEXP>(Rcpp::wrap(tab1)), Shield<SEXP>(Rcpp::wrap(tab2)));
        }
        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 tab_div_(const NumericVector& tab1, const NumericVector& tab2) {
        typedef SEXP(*Ptr_tab_div_)(SEXP,SEXP);
        static Ptr_tab_div_ p_tab_div_ = NULL;
        if (p_tab_div_ == NULL) {
            validateSignature("NumericVector(*tab_div_)(const NumericVector&,const NumericVector&)");
            p_tab_div_ = (Ptr_tab_div_)R_GetCCallable("gRbase", "_gRbase_tab_div_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_div_(Shield<SEXP>(Rcpp::wrap(tab1)), Shield<SEXP>(Rcpp::wrap(tab2)));
        }
        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 tab_div0_(const NumericVector& tab1, const NumericVector& tab2) {
        typedef SEXP(*Ptr_tab_div0_)(SEXP,SEXP);
        static Ptr_tab_div0_ p_tab_div0_ = NULL;
        if (p_tab_div0_ == NULL) {
            validateSignature("NumericVector(*tab_div0_)(const NumericVector&,const NumericVector&)");
            p_tab_div0_ = (Ptr_tab_div0_)R_GetCCallable("gRbase", "_gRbase_tab_div0_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_div0_(Shield<SEXP>(Rcpp::wrap(tab1)), Shield<SEXP>(Rcpp::wrap(tab2)));
        }
        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 bool tab_equal_(const NumericVector& tab1, const NumericVector& tab2, double eps = 1e-12) {
        typedef SEXP(*Ptr_tab_equal_)(SEXP,SEXP,SEXP);
        static Ptr_tab_equal_ p_tab_equal_ = NULL;
        if (p_tab_equal_ == NULL) {
            validateSignature("bool(*tab_equal_)(const NumericVector&,const NumericVector&,double)");
            p_tab_equal_ = (Ptr_tab_equal_)R_GetCCallable("gRbase", "_gRbase_tab_equal_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_equal_(Shield<SEXP>(Rcpp::wrap(tab1)), Shield<SEXP>(Rcpp::wrap(tab2)), Shield<SEXP>(Rcpp::wrap(eps)));
        }
        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 NumericVector tab_list_mult_(const List& lst) {
        typedef SEXP(*Ptr_tab_list_mult_)(SEXP);
        static Ptr_tab_list_mult_ p_tab_list_mult_ = NULL;
        if (p_tab_list_mult_ == NULL) {
            validateSignature("NumericVector(*tab_list_mult_)(const List&)");
            p_tab_list_mult_ = (Ptr_tab_list_mult_)R_GetCCallable("gRbase", "_gRbase_tab_list_mult_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_list_mult_(Shield<SEXP>(Rcpp::wrap(lst)));
        }
        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 tab_list_add_(const List& lst) {
        typedef SEXP(*Ptr_tab_list_add_)(SEXP);
        static Ptr_tab_list_add_ p_tab_list_add_ = NULL;
        if (p_tab_list_add_ == NULL) {
            validateSignature("NumericVector(*tab_list_add_)(const List&)");
            p_tab_list_add_ = (Ptr_tab_list_add_)R_GetCCallable("gRbase", "_gRbase_tab_list_add_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tab_list_add_(Shield<SEXP>(Rcpp::wrap(lst)));
        }
        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 SEXP tabMarg__(const SEXP& tab, const SEXP& marg) {
        typedef SEXP(*Ptr_tabMarg__)(SEXP,SEXP);
        static Ptr_tabMarg__ p_tabMarg__ = NULL;
        if (p_tabMarg__ == NULL) {
            validateSignature("SEXP(*tabMarg__)(const SEXP&,const SEXP&)");
            p_tabMarg__ = (Ptr_tabMarg__)R_GetCCallable("gRbase", "_gRbase_tabMarg__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tabMarg__(Shield<SEXP>(Rcpp::wrap(tab)), Shield<SEXP>(Rcpp::wrap(marg)));
        }
        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 NumericVector tabDiv0__(const NumericVector& tab1, const NumericVector& tab2) {
        typedef SEXP(*Ptr_tabDiv0__)(SEXP,SEXP);
        static Ptr_tabDiv0__ p_tabDiv0__ = NULL;
        if (p_tabDiv0__ == NULL) {
            validateSignature("NumericVector(*tabDiv0__)(const NumericVector&,const NumericVector&)");
            p_tabDiv0__ = (Ptr_tabDiv0__)R_GetCCallable("gRbase", "_gRbase_tabDiv0__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tabDiv0__(Shield<SEXP>(Rcpp::wrap(tab1)), Shield<SEXP>(Rcpp::wrap(tab2)));
        }
        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 tabMult__(const NumericVector& tab1, const NumericVector& tab2) {
        typedef SEXP(*Ptr_tabMult__)(SEXP,SEXP);
        static Ptr_tabMult__ p_tabMult__ = NULL;
        if (p_tabMult__ == NULL) {
            validateSignature("NumericVector(*tabMult__)(const NumericVector&,const NumericVector&)");
            p_tabMult__ = (Ptr_tabMult__)R_GetCCallable("gRbase", "_gRbase_tabMult__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_tabMult__(Shield<SEXP>(Rcpp::wrap(tab1)), Shield<SEXP>(Rcpp::wrap(tab2)));
        }
        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 CharacterVector unlist_chr__(const List& list) {
        typedef SEXP(*Ptr_unlist_chr__)(SEXP);
        static Ptr_unlist_chr__ p_unlist_chr__ = NULL;
        if (p_unlist_chr__ == NULL) {
            validateSignature("CharacterVector(*unlist_chr__)(const List&)");
            p_unlist_chr__ = (Ptr_unlist_chr__)R_GetCCallable("gRbase", "_gRbase_unlist_chr__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_unlist_chr__(Shield<SEXP>(Rcpp::wrap(list)));
        }
        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<CharacterVector >(rcpp_result_gen);
    }

    inline List adjList2tfList__(List LL) {
        typedef SEXP(*Ptr_adjList2tfList__)(SEXP);
        static Ptr_adjList2tfList__ p_adjList2tfList__ = NULL;
        if (p_adjList2tfList__ == NULL) {
            validateSignature("List(*adjList2tfList__)(List)");
            p_adjList2tfList__ = (Ptr_adjList2tfList__)R_GetCCallable("gRbase", "_gRbase_adjList2tfList__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_adjList2tfList__(Shield<SEXP>(Rcpp::wrap(LL)));
        }
        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 adjList2ftList__(List LL) {
        typedef SEXP(*Ptr_adjList2ftList__)(SEXP);
        static Ptr_adjList2ftList__ p_adjList2ftList__ = NULL;
        if (p_adjList2ftList__ == NULL) {
            validateSignature("List(*adjList2ftList__)(List)");
            p_adjList2ftList__ = (Ptr_adjList2ftList__)R_GetCCallable("gRbase", "_gRbase_adjList2ftList__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_adjList2ftList__(Shield<SEXP>(Rcpp::wrap(LL)));
        }
        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 SEXP dagList2dgCMatrix__(List LL, Nullable<CharacterVector> vn = R_NilValue) {
        typedef SEXP(*Ptr_dagList2dgCMatrix__)(SEXP,SEXP);
        static Ptr_dagList2dgCMatrix__ p_dagList2dgCMatrix__ = NULL;
        if (p_dagList2dgCMatrix__ == NULL) {
            validateSignature("SEXP(*dagList2dgCMatrix__)(List,Nullable<CharacterVector>)");
            p_dagList2dgCMatrix__ = (Ptr_dagList2dgCMatrix__)R_GetCCallable("gRbase", "_gRbase_dagList2dgCMatrix__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_dagList2dgCMatrix__(Shield<SEXP>(Rcpp::wrap(LL)), Shield<SEXP>(Rcpp::wrap(vn)));
        }
        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 dagList2matrix__(List LL, Nullable<CharacterVector> vn = R_NilValue) {
        typedef SEXP(*Ptr_dagList2matrix__)(SEXP,SEXP);
        static Ptr_dagList2matrix__ p_dagList2matrix__ = NULL;
        if (p_dagList2matrix__ == NULL) {
            validateSignature("SEXP(*dagList2matrix__)(List,Nullable<CharacterVector>)");
            p_dagList2matrix__ = (Ptr_dagList2matrix__)R_GetCCallable("gRbase", "_gRbase_dagList2matrix__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_dagList2matrix__(Shield<SEXP>(Rcpp::wrap(LL)), Shield<SEXP>(Rcpp::wrap(vn)));
        }
        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 ugList2dgCMatrix__(List LL, Nullable<CharacterVector> vn = R_NilValue) {
        typedef SEXP(*Ptr_ugList2dgCMatrix__)(SEXP,SEXP);
        static Ptr_ugList2dgCMatrix__ p_ugList2dgCMatrix__ = NULL;
        if (p_ugList2dgCMatrix__ == NULL) {
            validateSignature("SEXP(*ugList2dgCMatrix__)(List,Nullable<CharacterVector>)");
            p_ugList2dgCMatrix__ = (Ptr_ugList2dgCMatrix__)R_GetCCallable("gRbase", "_gRbase_ugList2dgCMatrix__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_ugList2dgCMatrix__(Shield<SEXP>(Rcpp::wrap(LL)), Shield<SEXP>(Rcpp::wrap(vn)));
        }
        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 ugList2matrix__(List LL, Nullable<CharacterVector> vn = R_NilValue) {
        typedef SEXP(*Ptr_ugList2matrix__)(SEXP,SEXP);
        static Ptr_ugList2matrix__ p_ugList2matrix__ = NULL;
        if (p_ugList2matrix__ == NULL) {
            validateSignature("SEXP(*ugList2matrix__)(List,Nullable<CharacterVector>)");
            p_ugList2matrix__ = (Ptr_ugList2matrix__)R_GetCCallable("gRbase", "_gRbase_ugList2matrix__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_ugList2matrix__(Shield<SEXP>(Rcpp::wrap(LL)), Shield<SEXP>(Rcpp::wrap(vn)));
        }
        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 CharacterMatrix adjList2ftM__(List LL) {
        typedef SEXP(*Ptr_adjList2ftM__)(SEXP);
        static Ptr_adjList2ftM__ p_adjList2ftM__ = NULL;
        if (p_adjList2ftM__ == NULL) {
            validateSignature("CharacterMatrix(*adjList2ftM__)(List)");
            p_adjList2ftM__ = (Ptr_adjList2ftM__)R_GetCCallable("gRbase", "_gRbase_adjList2ftM__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_adjList2ftM__(Shield<SEXP>(Rcpp::wrap(LL)));
        }
        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<CharacterMatrix >(rcpp_result_gen);
    }

    inline CharacterMatrix adjList2tfM__(List LL) {
        typedef SEXP(*Ptr_adjList2tfM__)(SEXP);
        static Ptr_adjList2tfM__ p_adjList2tfM__ = NULL;
        if (p_adjList2tfM__ == NULL) {
            validateSignature("CharacterMatrix(*adjList2tfM__)(List)");
            p_adjList2tfM__ = (Ptr_adjList2tfM__)R_GetCCallable("gRbase", "_gRbase_adjList2tfM__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_adjList2tfM__(Shield<SEXP>(Rcpp::wrap(LL)));
        }
        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<CharacterMatrix >(rcpp_result_gen);
    }

    inline SEXP adjList2matrix__(List LL) {
        typedef SEXP(*Ptr_adjList2matrix__)(SEXP);
        static Ptr_adjList2matrix__ p_adjList2matrix__ = NULL;
        if (p_adjList2matrix__ == NULL) {
            validateSignature("SEXP(*adjList2matrix__)(List)");
            p_adjList2matrix__ = (Ptr_adjList2matrix__)R_GetCCallable("gRbase", "_gRbase_adjList2matrix__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_adjList2matrix__(Shield<SEXP>(Rcpp::wrap(LL)));
        }
        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 adjList2dgCMatrix__(List LL) {
        typedef SEXP(*Ptr_adjList2dgCMatrix__)(SEXP);
        static Ptr_adjList2dgCMatrix__ p_adjList2dgCMatrix__ = NULL;
        if (p_adjList2dgCMatrix__ == NULL) {
            validateSignature("SEXP(*adjList2dgCMatrix__)(List)");
            p_adjList2dgCMatrix__ = (Ptr_adjList2dgCMatrix__)R_GetCCallable("gRbase", "_gRbase_adjList2dgCMatrix__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_adjList2dgCMatrix__(Shield<SEXP>(Rcpp::wrap(LL)));
        }
        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 IntegerVector which_(SEXP x) {
        typedef SEXP(*Ptr_which_)(SEXP);
        static Ptr_which_ p_which_ = NULL;
        if (p_which_ == NULL) {
            validateSignature("IntegerVector(*which_)(SEXP)");
            p_which_ = (Ptr_which_)R_GetCCallable("gRbase", "_gRbase_which_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_which_(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<IntegerVector >(rcpp_result_gen);
    }

    inline IntegerVector get_superset_(CharacterVector x, List setlist, bool all = false) {
        typedef SEXP(*Ptr_get_superset_)(SEXP,SEXP,SEXP);
        static Ptr_get_superset_ p_get_superset_ = NULL;
        if (p_get_superset_ == NULL) {
            validateSignature("IntegerVector(*get_superset_)(CharacterVector,List,bool)");
            p_get_superset_ = (Ptr_get_superset_)R_GetCCallable("gRbase", "_gRbase_get_superset_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_get_superset_(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(setlist)), Shield<SEXP>(Rcpp::wrap(all)));
        }
        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 get_subset_(CharacterVector x, List setlist, bool all = false) {
        typedef SEXP(*Ptr_get_subset_)(SEXP,SEXP,SEXP);
        static Ptr_get_subset_ p_get_subset_ = NULL;
        if (p_get_subset_ == NULL) {
            validateSignature("IntegerVector(*get_subset_)(CharacterVector,List,bool)");
            p_get_subset_ = (Ptr_get_subset_)R_GetCCallable("gRbase", "_gRbase_get_subset_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_get_subset_(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(setlist)), Shield<SEXP>(Rcpp::wrap(all)));
        }
        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 bool is_subsetof_(SEXP set, SEXP set2) {
        typedef SEXP(*Ptr_is_subsetof_)(SEXP,SEXP);
        static Ptr_is_subsetof_ p_is_subsetof_ = NULL;
        if (p_is_subsetof_ == NULL) {
            validateSignature("bool(*is_subsetof_)(SEXP,SEXP)");
            p_is_subsetof_ = (Ptr_is_subsetof_)R_GetCCallable("gRbase", "_gRbase_is_subsetof_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_is_subsetof_(Shield<SEXP>(Rcpp::wrap(set)), Shield<SEXP>(Rcpp::wrap(set2)));
        }
        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 List allSubsets0_(const IntegerVector& x) {
        typedef SEXP(*Ptr_allSubsets0_)(SEXP);
        static Ptr_allSubsets0_ p_allSubsets0_ = NULL;
        if (p_allSubsets0_ == NULL) {
            validateSignature("List(*allSubsets0_)(const IntegerVector&)");
            p_allSubsets0_ = (Ptr_allSubsets0_)R_GetCCallable("gRbase", "_gRbase_allSubsets0_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_allSubsets0_(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<List >(rcpp_result_gen);
    }

    inline SEXP allSubsets_(SEXP& x) {
        typedef SEXP(*Ptr_allSubsets_)(SEXP);
        static Ptr_allSubsets_ p_allSubsets_ = NULL;
        if (p_allSubsets_ == NULL) {
            validateSignature("SEXP(*allSubsets_)(SEXP&)");
            p_allSubsets_ = (Ptr_allSubsets_)R_GetCCallable("gRbase", "_gRbase_allSubsets_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_allSubsets_(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<SEXP >(rcpp_result_gen);
    }

    inline SEXP all_pairs__(CharacterVector x, CharacterVector y = CharacterVector(0), bool sort = false, std::string result = "matrix") {
        typedef SEXP(*Ptr_all_pairs__)(SEXP,SEXP,SEXP,SEXP);
        static Ptr_all_pairs__ p_all_pairs__ = NULL;
        if (p_all_pairs__ == NULL) {
            validateSignature("SEXP(*all_pairs__)(CharacterVector,CharacterVector,bool,std::string)");
            p_all_pairs__ = (Ptr_all_pairs__)R_GetCCallable("gRbase", "_gRbase_all_pairs__");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_all_pairs__(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(y)), Shield<SEXP>(Rcpp::wrap(sort)), Shield<SEXP>(Rcpp::wrap(result)));
        }
        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 max_set_(const List L, bool index = false) {
        typedef SEXP(*Ptr_max_set_)(SEXP,SEXP);
        static Ptr_max_set_ p_max_set_ = NULL;
        if (p_max_set_ == NULL) {
            validateSignature("SEXP(*max_set_)(const List,bool)");
            p_max_set_ = (Ptr_max_set_)R_GetCCallable("gRbase", "_gRbase_max_set_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_max_set_(Shield<SEXP>(Rcpp::wrap(L)), Shield<SEXP>(Rcpp::wrap(index)));
        }
        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 min_set_(const List L, bool index = false) {
        typedef SEXP(*Ptr_min_set_)(SEXP,SEXP);
        static Ptr_min_set_ p_min_set_ = NULL;
        if (p_min_set_ == NULL) {
            validateSignature("SEXP(*min_set_)(const List,bool)");
            p_min_set_ = (Ptr_min_set_)R_GetCCallable("gRbase", "_gRbase_min_set_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_min_set_(Shield<SEXP>(Rcpp::wrap(L)), Shield<SEXP>(Rcpp::wrap(index)));
        }
        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 isin_(List L, SEXP set, bool index = false) {
        typedef SEXP(*Ptr_isin_)(SEXP,SEXP,SEXP);
        static Ptr_isin_ p_isin_ = NULL;
        if (p_isin_ == NULL) {
            validateSignature("SEXP(*isin_)(List,SEXP,bool)");
            p_isin_ = (Ptr_isin_)R_GetCCallable("gRbase", "_gRbase_isin_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_isin_(Shield<SEXP>(Rcpp::wrap(L)), Shield<SEXP>(Rcpp::wrap(set)), Shield<SEXP>(Rcpp::wrap(index)));
        }
        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 int choose_(int N, int K) {
        typedef SEXP(*Ptr_choose_)(SEXP,SEXP);
        static Ptr_choose_ p_choose_ = NULL;
        if (p_choose_ == NULL) {
            validateSignature("int(*choose_)(int,int)");
            p_choose_ = (Ptr_choose_)R_GetCCallable("gRbase", "_gRbase_choose_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_choose_(Shield<SEXP>(Rcpp::wrap(N)), Shield<SEXP>(Rcpp::wrap(K)));
        }
        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<int >(rcpp_result_gen);
    }

    inline IntegerMatrix do_combn(int N, int K) {
        typedef SEXP(*Ptr_do_combn)(SEXP,SEXP);
        static Ptr_do_combn p_do_combn = NULL;
        if (p_do_combn == NULL) {
            validateSignature("IntegerMatrix(*do_combn)(int,int)");
            p_do_combn = (Ptr_do_combn)R_GetCCallable("gRbase", "_gRbase_do_combn");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_do_combn(Shield<SEXP>(Rcpp::wrap(N)), Shield<SEXP>(Rcpp::wrap(K)));
        }
        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<IntegerMatrix >(rcpp_result_gen);
    }

    inline void next_perm_(IntegerVector& vv) {
        typedef SEXP(*Ptr_next_perm_)(SEXP);
        static Ptr_next_perm_ p_next_perm_ = NULL;
        if (p_next_perm_ == NULL) {
            validateSignature("void(*next_perm_)(IntegerVector&)");
            p_next_perm_ = (Ptr_next_perm_)R_GetCCallable("gRbase", "_gRbase_next_perm_");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_next_perm_(Shield<SEXP>(Rcpp::wrap(vv)));
        }
        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());
    }

}

#endif // RCPP_gRbase_RCPPEXPORTS_H_GEN_
