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

#ifndef RCPP_RcppCWB_RCPPEXPORTS_H_GEN_
#define RCPP_RcppCWB_RCPPEXPORTS_H_GEN_

#include <Rcpp.h>

namespace RcppCWB {

    using namespace Rcpp;

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

    inline Rcpp::StringVector _cwb_version() {
        typedef SEXP(*Ptr__cwb_version)();
        static Ptr__cwb_version p__cwb_version = NULL;
        if (p__cwb_version == NULL) {
            validateSignature("Rcpp::StringVector(*_cwb_version)()");
            p__cwb_version = (Ptr__cwb_version)R_GetCCallable("RcppCWB", "_RcppCWB__cwb_version");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cwb_version();
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::StringVector p_attr_default() {
        typedef SEXP(*Ptr_p_attr_default)();
        static Ptr_p_attr_default p_p_attr_default = NULL;
        if (p_p_attr_default == NULL) {
            validateSignature("Rcpp::StringVector(*p_attr_default)()");
            p_p_attr_default = (Ptr_p_attr_default)R_GetCCallable("RcppCWB", "_RcppCWB_p_attr_default");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_p_attr_default();
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline SEXP s_attr(SEXP corpus, SEXP s_attribute, SEXP registry) {
        typedef SEXP(*Ptr_s_attr)(SEXP,SEXP,SEXP);
        static Ptr_s_attr p_s_attr = NULL;
        if (p_s_attr == NULL) {
            validateSignature("SEXP(*s_attr)(SEXP,SEXP,SEXP)");
            p_s_attr = (Ptr_s_attr)R_GetCCallable("RcppCWB", "_RcppCWB_s_attr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_s_attr(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(s_attribute)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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 p_attr(SEXP corpus, SEXP p_attribute, SEXP registry) {
        typedef SEXP(*Ptr_p_attr)(SEXP,SEXP,SEXP);
        static Ptr_p_attr p_p_attr = NULL;
        if (p_p_attr == NULL) {
            validateSignature("SEXP(*p_attr)(SEXP,SEXP,SEXP)");
            p_p_attr = (Ptr_p_attr)R_GetCCallable("RcppCWB", "_RcppCWB_p_attr");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_p_attr(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(p_attribute)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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 attribute_size(SEXP corpus, SEXP attribute, SEXP attribute_type, SEXP registry) {
        typedef SEXP(*Ptr_attribute_size)(SEXP,SEXP,SEXP,SEXP);
        static Ptr_attribute_size p_attribute_size = NULL;
        if (p_attribute_size == NULL) {
            validateSignature("int(*attribute_size)(SEXP,SEXP,SEXP,SEXP)");
            p_attribute_size = (Ptr_attribute_size)R_GetCCallable("RcppCWB", "_RcppCWB_attribute_size");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_attribute_size(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(attribute)), Shield<SEXP>(Rcpp::wrap(attribute_type)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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 int p_attr_size(SEXP p_attr) {
        typedef SEXP(*Ptr_p_attr_size)(SEXP);
        static Ptr_p_attr_size p_p_attr_size = NULL;
        if (p_p_attr_size == NULL) {
            validateSignature("int(*p_attr_size)(SEXP)");
            p_p_attr_size = (Ptr_p_attr_size)R_GetCCallable("RcppCWB", "_RcppCWB_p_attr_size");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_p_attr_size(Shield<SEXP>(Rcpp::wrap(p_attr)));
        }
        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 int s_attr_size(SEXP s_attr) {
        typedef SEXP(*Ptr_s_attr_size)(SEXP);
        static Ptr_s_attr_size p_s_attr_size = NULL;
        if (p_s_attr_size == NULL) {
            validateSignature("int(*s_attr_size)(SEXP)");
            p_s_attr_size = (Ptr_s_attr_size)R_GetCCallable("RcppCWB", "_RcppCWB_s_attr_size");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_s_attr_size(Shield<SEXP>(Rcpp::wrap(s_attr)));
        }
        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 int p_attr_lexicon_size(SEXP p_attr) {
        typedef SEXP(*Ptr_p_attr_lexicon_size)(SEXP);
        static Ptr_p_attr_lexicon_size p_p_attr_lexicon_size = NULL;
        if (p_p_attr_lexicon_size == NULL) {
            validateSignature("int(*p_attr_lexicon_size)(SEXP)");
            p_p_attr_lexicon_size = (Ptr_p_attr_lexicon_size)R_GetCCallable("RcppCWB", "_RcppCWB_p_attr_lexicon_size");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_p_attr_lexicon_size(Shield<SEXP>(Rcpp::wrap(p_attr)));
        }
        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 int _cl_lexicon_size(SEXP corpus, SEXP p_attribute, SEXP registry) {
        typedef SEXP(*Ptr__cl_lexicon_size)(SEXP,SEXP,SEXP);
        static Ptr__cl_lexicon_size p__cl_lexicon_size = NULL;
        if (p__cl_lexicon_size == NULL) {
            validateSignature("int(*_cl_lexicon_size)(SEXP,SEXP,SEXP)");
            p__cl_lexicon_size = (Ptr__cl_lexicon_size)R_GetCCallable("RcppCWB", "_RcppCWB__cl_lexicon_size");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_lexicon_size(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(p_attribute)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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 Rcpp::IntegerVector _cl_cpos2struc(SEXP corpus, SEXP s_attribute, Rcpp::IntegerVector cpos, SEXP registry) {
        typedef SEXP(*Ptr__cl_cpos2struc)(SEXP,SEXP,SEXP,SEXP);
        static Ptr__cl_cpos2struc p__cl_cpos2struc = NULL;
        if (p__cl_cpos2struc == NULL) {
            validateSignature("Rcpp::IntegerVector(*_cl_cpos2struc)(SEXP,SEXP,Rcpp::IntegerVector,SEXP)");
            p__cl_cpos2struc = (Ptr__cl_cpos2struc)R_GetCCallable("RcppCWB", "_RcppCWB__cl_cpos2struc");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_cpos2struc(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(s_attribute)), Shield<SEXP>(Rcpp::wrap(cpos)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector cpos_to_struc(SEXP s_attr, Rcpp::IntegerVector cpos) {
        typedef SEXP(*Ptr_cpos_to_struc)(SEXP,SEXP);
        static Ptr_cpos_to_struc p_cpos_to_struc = NULL;
        if (p_cpos_to_struc == NULL) {
            validateSignature("Rcpp::IntegerVector(*cpos_to_struc)(SEXP,Rcpp::IntegerVector)");
            p_cpos_to_struc = (Ptr_cpos_to_struc)R_GetCCallable("RcppCWB", "_RcppCWB_cpos_to_struc");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpos_to_struc(Shield<SEXP>(Rcpp::wrap(s_attr)), Shield<SEXP>(Rcpp::wrap(cpos)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::StringVector cpos2str(SEXP corpus, SEXP p_attribute, SEXP registry, Rcpp::IntegerVector cpos) {
        typedef SEXP(*Ptr_cpos2str)(SEXP,SEXP,SEXP,SEXP);
        static Ptr_cpos2str p_cpos2str = NULL;
        if (p_cpos2str == NULL) {
            validateSignature("Rcpp::StringVector(*cpos2str)(SEXP,SEXP,SEXP,Rcpp::IntegerVector)");
            p_cpos2str = (Ptr_cpos2str)R_GetCCallable("RcppCWB", "_RcppCWB_cpos2str");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpos2str(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(p_attribute)), Shield<SEXP>(Rcpp::wrap(registry)), Shield<SEXP>(Rcpp::wrap(cpos)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::StringVector cpos_to_str(SEXP p_attr, Rcpp::IntegerVector cpos) {
        typedef SEXP(*Ptr_cpos_to_str)(SEXP,SEXP);
        static Ptr_cpos_to_str p_cpos_to_str = NULL;
        if (p_cpos_to_str == NULL) {
            validateSignature("Rcpp::StringVector(*cpos_to_str)(SEXP,Rcpp::IntegerVector)");
            p_cpos_to_str = (Ptr_cpos_to_str)R_GetCCallable("RcppCWB", "_RcppCWB_cpos_to_str");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpos_to_str(Shield<SEXP>(Rcpp::wrap(p_attr)), Shield<SEXP>(Rcpp::wrap(cpos)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector cpos2id(SEXP corpus, SEXP p_attribute, SEXP registry, Rcpp::IntegerVector cpos) {
        typedef SEXP(*Ptr_cpos2id)(SEXP,SEXP,SEXP,SEXP);
        static Ptr_cpos2id p_cpos2id = NULL;
        if (p_cpos2id == NULL) {
            validateSignature("Rcpp::IntegerVector(*cpos2id)(SEXP,SEXP,SEXP,Rcpp::IntegerVector)");
            p_cpos2id = (Ptr_cpos2id)R_GetCCallable("RcppCWB", "_RcppCWB_cpos2id");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpos2id(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(p_attribute)), Shield<SEXP>(Rcpp::wrap(registry)), Shield<SEXP>(Rcpp::wrap(cpos)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector cpos_to_id(SEXP p_attr, Rcpp::IntegerVector cpos) {
        typedef SEXP(*Ptr_cpos_to_id)(SEXP,SEXP);
        static Ptr_cpos_to_id p_cpos_to_id = NULL;
        if (p_cpos_to_id == NULL) {
            validateSignature("Rcpp::IntegerVector(*cpos_to_id)(SEXP,Rcpp::IntegerVector)");
            p_cpos_to_id = (Ptr_cpos_to_id)R_GetCCallable("RcppCWB", "_RcppCWB_cpos_to_id");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpos_to_id(Shield<SEXP>(Rcpp::wrap(p_attr)), Shield<SEXP>(Rcpp::wrap(cpos)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector struc2cpos(SEXP corpus, SEXP s_attribute, SEXP registry, int struc) {
        typedef SEXP(*Ptr_struc2cpos)(SEXP,SEXP,SEXP,SEXP);
        static Ptr_struc2cpos p_struc2cpos = NULL;
        if (p_struc2cpos == NULL) {
            validateSignature("Rcpp::IntegerVector(*struc2cpos)(SEXP,SEXP,SEXP,int)");
            p_struc2cpos = (Ptr_struc2cpos)R_GetCCallable("RcppCWB", "_RcppCWB_struc2cpos");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_struc2cpos(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(s_attribute)), Shield<SEXP>(Rcpp::wrap(registry)), Shield<SEXP>(Rcpp::wrap(struc)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector struc_to_cpos(SEXP s_attr, int struc) {
        typedef SEXP(*Ptr_struc_to_cpos)(SEXP,SEXP);
        static Ptr_struc_to_cpos p_struc_to_cpos = NULL;
        if (p_struc_to_cpos == NULL) {
            validateSignature("Rcpp::IntegerVector(*struc_to_cpos)(SEXP,int)");
            p_struc_to_cpos = (Ptr_struc_to_cpos)R_GetCCallable("RcppCWB", "_RcppCWB_struc_to_cpos");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_struc_to_cpos(Shield<SEXP>(Rcpp::wrap(s_attr)), Shield<SEXP>(Rcpp::wrap(struc)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::StringVector id2str(SEXP corpus, SEXP p_attribute, SEXP registry, Rcpp::IntegerVector id) {
        typedef SEXP(*Ptr_id2str)(SEXP,SEXP,SEXP,SEXP);
        static Ptr_id2str p_id2str = NULL;
        if (p_id2str == NULL) {
            validateSignature("Rcpp::StringVector(*id2str)(SEXP,SEXP,SEXP,Rcpp::IntegerVector)");
            p_id2str = (Ptr_id2str)R_GetCCallable("RcppCWB", "_RcppCWB_id2str");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_id2str(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(p_attribute)), Shield<SEXP>(Rcpp::wrap(registry)), Shield<SEXP>(Rcpp::wrap(id)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::StringVector _cl_struc2str(SEXP corpus, SEXP s_attribute, Rcpp::IntegerVector struc, SEXP registry) {
        typedef SEXP(*Ptr__cl_struc2str)(SEXP,SEXP,SEXP,SEXP);
        static Ptr__cl_struc2str p__cl_struc2str = NULL;
        if (p__cl_struc2str == NULL) {
            validateSignature("Rcpp::StringVector(*_cl_struc2str)(SEXP,SEXP,Rcpp::IntegerVector,SEXP)");
            p__cl_struc2str = (Ptr__cl_struc2str)R_GetCCallable("RcppCWB", "_RcppCWB__cl_struc2str");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_struc2str(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(s_attribute)), Shield<SEXP>(Rcpp::wrap(struc)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::StringVector struc_to_str(SEXP s_attr, Rcpp::IntegerVector struc) {
        typedef SEXP(*Ptr_struc_to_str)(SEXP,SEXP);
        static Ptr_struc_to_str p_struc_to_str = NULL;
        if (p_struc_to_str == NULL) {
            validateSignature("Rcpp::StringVector(*struc_to_str)(SEXP,Rcpp::IntegerVector)");
            p_struc_to_str = (Ptr_struc_to_str)R_GetCCallable("RcppCWB", "_RcppCWB_struc_to_str");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_struc_to_str(Shield<SEXP>(Rcpp::wrap(s_attr)), Shield<SEXP>(Rcpp::wrap(struc)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector _cl_regex2id(SEXP corpus, SEXP p_attribute, SEXP regex, SEXP registry) {
        typedef SEXP(*Ptr__cl_regex2id)(SEXP,SEXP,SEXP,SEXP);
        static Ptr__cl_regex2id p__cl_regex2id = NULL;
        if (p__cl_regex2id == NULL) {
            validateSignature("Rcpp::IntegerVector(*_cl_regex2id)(SEXP,SEXP,SEXP,SEXP)");
            p__cl_regex2id = (Ptr__cl_regex2id)R_GetCCallable("RcppCWB", "_RcppCWB__cl_regex2id");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_regex2id(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(p_attribute)), Shield<SEXP>(Rcpp::wrap(regex)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector regex_to_id(SEXP p_attr, SEXP regex) {
        typedef SEXP(*Ptr_regex_to_id)(SEXP,SEXP);
        static Ptr_regex_to_id p_regex_to_id = NULL;
        if (p_regex_to_id == NULL) {
            validateSignature("Rcpp::IntegerVector(*regex_to_id)(SEXP,SEXP)");
            p_regex_to_id = (Ptr_regex_to_id)R_GetCCallable("RcppCWB", "_RcppCWB_regex_to_id");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_regex_to_id(Shield<SEXP>(Rcpp::wrap(p_attr)), Shield<SEXP>(Rcpp::wrap(regex)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector _cl_str2id(SEXP corpus, SEXP p_attribute, Rcpp::StringVector str, SEXP registry) {
        typedef SEXP(*Ptr__cl_str2id)(SEXP,SEXP,SEXP,SEXP);
        static Ptr__cl_str2id p__cl_str2id = NULL;
        if (p__cl_str2id == NULL) {
            validateSignature("Rcpp::IntegerVector(*_cl_str2id)(SEXP,SEXP,Rcpp::StringVector,SEXP)");
            p__cl_str2id = (Ptr__cl_str2id)R_GetCCallable("RcppCWB", "_RcppCWB__cl_str2id");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_str2id(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(p_attribute)), Shield<SEXP>(Rcpp::wrap(str)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector str_to_id(SEXP p_attr, Rcpp::StringVector str) {
        typedef SEXP(*Ptr_str_to_id)(SEXP,SEXP);
        static Ptr_str_to_id p_str_to_id = NULL;
        if (p_str_to_id == NULL) {
            validateSignature("Rcpp::IntegerVector(*str_to_id)(SEXP,Rcpp::StringVector)");
            p_str_to_id = (Ptr_str_to_id)R_GetCCallable("RcppCWB", "_RcppCWB_str_to_id");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_str_to_id(Shield<SEXP>(Rcpp::wrap(p_attr)), Shield<SEXP>(Rcpp::wrap(str)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector _cl_id2freq(SEXP corpus, SEXP p_attribute, Rcpp::IntegerVector id, SEXP registry) {
        typedef SEXP(*Ptr__cl_id2freq)(SEXP,SEXP,SEXP,SEXP);
        static Ptr__cl_id2freq p__cl_id2freq = NULL;
        if (p__cl_id2freq == NULL) {
            validateSignature("Rcpp::IntegerVector(*_cl_id2freq)(SEXP,SEXP,Rcpp::IntegerVector,SEXP)");
            p__cl_id2freq = (Ptr__cl_id2freq)R_GetCCallable("RcppCWB", "_RcppCWB__cl_id2freq");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_id2freq(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(p_attribute)), Shield<SEXP>(Rcpp::wrap(id)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector id_to_freq(SEXP p_attr, Rcpp::IntegerVector id) {
        typedef SEXP(*Ptr_id_to_freq)(SEXP,SEXP);
        static Ptr_id_to_freq p_id_to_freq = NULL;
        if (p_id_to_freq == NULL) {
            validateSignature("Rcpp::IntegerVector(*id_to_freq)(SEXP,Rcpp::IntegerVector)");
            p_id_to_freq = (Ptr_id_to_freq)R_GetCCallable("RcppCWB", "_RcppCWB_id_to_freq");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_id_to_freq(Shield<SEXP>(Rcpp::wrap(p_attr)), Shield<SEXP>(Rcpp::wrap(id)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector _cl_id2cpos(SEXP corpus, SEXP p_attribute, SEXP id, SEXP registry) {
        typedef SEXP(*Ptr__cl_id2cpos)(SEXP,SEXP,SEXP,SEXP);
        static Ptr__cl_id2cpos p__cl_id2cpos = NULL;
        if (p__cl_id2cpos == NULL) {
            validateSignature("Rcpp::IntegerVector(*_cl_id2cpos)(SEXP,SEXP,SEXP,SEXP)");
            p__cl_id2cpos = (Ptr__cl_id2cpos)R_GetCCallable("RcppCWB", "_RcppCWB__cl_id2cpos");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_id2cpos(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(p_attribute)), Shield<SEXP>(Rcpp::wrap(id)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector id_to_cpos(SEXP p_attr, Rcpp::IntegerVector id) {
        typedef SEXP(*Ptr_id_to_cpos)(SEXP,SEXP);
        static Ptr_id_to_cpos p_id_to_cpos = NULL;
        if (p_id_to_cpos == NULL) {
            validateSignature("Rcpp::IntegerVector(*id_to_cpos)(SEXP,Rcpp::IntegerVector)");
            p_id_to_cpos = (Ptr_id_to_cpos)R_GetCCallable("RcppCWB", "_RcppCWB_id_to_cpos");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_id_to_cpos(Shield<SEXP>(Rcpp::wrap(p_attr)), Shield<SEXP>(Rcpp::wrap(id)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector cl_cpos2lbound(SEXP corpus, SEXP s_attribute, Rcpp::IntegerVector cpos, SEXP registry = R_NilValue) {
        typedef SEXP(*Ptr_cl_cpos2lbound)(SEXP,SEXP,SEXP,SEXP);
        static Ptr_cl_cpos2lbound p_cl_cpos2lbound = NULL;
        if (p_cl_cpos2lbound == NULL) {
            validateSignature("Rcpp::IntegerVector(*cl_cpos2lbound)(SEXP,SEXP,Rcpp::IntegerVector,SEXP)");
            p_cl_cpos2lbound = (Ptr_cl_cpos2lbound)R_GetCCallable("RcppCWB", "_RcppCWB_cl_cpos2lbound");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cl_cpos2lbound(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(s_attribute)), Shield<SEXP>(Rcpp::wrap(cpos)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector cpos_to_lbound(SEXP s_attr, Rcpp::IntegerVector cpos) {
        typedef SEXP(*Ptr_cpos_to_lbound)(SEXP,SEXP);
        static Ptr_cpos_to_lbound p_cpos_to_lbound = NULL;
        if (p_cpos_to_lbound == NULL) {
            validateSignature("Rcpp::IntegerVector(*cpos_to_lbound)(SEXP,Rcpp::IntegerVector)");
            p_cpos_to_lbound = (Ptr_cpos_to_lbound)R_GetCCallable("RcppCWB", "_RcppCWB_cpos_to_lbound");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpos_to_lbound(Shield<SEXP>(Rcpp::wrap(s_attr)), Shield<SEXP>(Rcpp::wrap(cpos)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector cl_cpos2rbound(SEXP corpus, SEXP s_attribute, Rcpp::IntegerVector cpos, SEXP registry = R_NilValue) {
        typedef SEXP(*Ptr_cl_cpos2rbound)(SEXP,SEXP,SEXP,SEXP);
        static Ptr_cl_cpos2rbound p_cl_cpos2rbound = NULL;
        if (p_cl_cpos2rbound == NULL) {
            validateSignature("Rcpp::IntegerVector(*cl_cpos2rbound)(SEXP,SEXP,Rcpp::IntegerVector,SEXP)");
            p_cl_cpos2rbound = (Ptr_cl_cpos2rbound)R_GetCCallable("RcppCWB", "_RcppCWB_cl_cpos2rbound");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cl_cpos2rbound(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(s_attribute)), Shield<SEXP>(Rcpp::wrap(cpos)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerVector cpos_to_rbound(SEXP s_attr, Rcpp::IntegerVector cpos) {
        typedef SEXP(*Ptr_cpos_to_rbound)(SEXP,SEXP);
        static Ptr_cpos_to_rbound p_cpos_to_rbound = NULL;
        if (p_cpos_to_rbound == NULL) {
            validateSignature("Rcpp::IntegerVector(*cpos_to_rbound)(SEXP,Rcpp::IntegerVector)");
            p_cpos_to_rbound = (Ptr_cpos_to_rbound)R_GetCCallable("RcppCWB", "_RcppCWB_cpos_to_rbound");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p_cpos_to_rbound(Shield<SEXP>(Rcpp::wrap(s_attr)), Shield<SEXP>(Rcpp::wrap(cpos)));
        }
        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::IntegerVector >(rcpp_result_gen);
    }

    inline SEXP _cl_find_corpus(SEXP corpus, SEXP registry) {
        typedef SEXP(*Ptr__cl_find_corpus)(SEXP,SEXP);
        static Ptr__cl_find_corpus p__cl_find_corpus = NULL;
        if (p__cl_find_corpus == NULL) {
            validateSignature("SEXP(*_cl_find_corpus)(SEXP,SEXP)");
            p__cl_find_corpus = (Ptr__cl_find_corpus)R_GetCCallable("RcppCWB", "_RcppCWB__cl_find_corpus");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_find_corpus(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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 _cl_new_attribute(SEXP corpus_pointer, SEXP s_attribute, int type) {
        typedef SEXP(*Ptr__cl_new_attribute)(SEXP,SEXP,SEXP);
        static Ptr__cl_new_attribute p__cl_new_attribute = NULL;
        if (p__cl_new_attribute == NULL) {
            validateSignature("SEXP(*_cl_new_attribute)(SEXP,SEXP,int)");
            p__cl_new_attribute = (Ptr__cl_new_attribute)R_GetCCallable("RcppCWB", "_RcppCWB__cl_new_attribute");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_new_attribute(Shield<SEXP>(Rcpp::wrap(corpus_pointer)), Shield<SEXP>(Rcpp::wrap(s_attribute)), 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 int _cl_delete_corpus(SEXP corpus, SEXP registry) {
        typedef SEXP(*Ptr__cl_delete_corpus)(SEXP,SEXP);
        static Ptr__cl_delete_corpus p__cl_delete_corpus = NULL;
        if (p__cl_delete_corpus == NULL) {
            validateSignature("int(*_cl_delete_corpus)(SEXP,SEXP)");
            p__cl_delete_corpus = (Ptr__cl_delete_corpus)R_GetCCallable("RcppCWB", "_RcppCWB__cl_delete_corpus");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_delete_corpus(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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 int _corpus_is_loaded(SEXP corpus, SEXP registry) {
        typedef SEXP(*Ptr__corpus_is_loaded)(SEXP,SEXP);
        static Ptr__corpus_is_loaded p__corpus_is_loaded = NULL;
        if (p__corpus_is_loaded == NULL) {
            validateSignature("int(*_corpus_is_loaded)(SEXP,SEXP)");
            p__corpus_is_loaded = (Ptr__corpus_is_loaded)R_GetCCallable("RcppCWB", "_RcppCWB__corpus_is_loaded");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__corpus_is_loaded(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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 Rcpp::StringVector _cl_charset_name(SEXP corpus, SEXP registry) {
        typedef SEXP(*Ptr__cl_charset_name)(SEXP,SEXP);
        static Ptr__cl_charset_name p__cl_charset_name = NULL;
        if (p__cl_charset_name == NULL) {
            validateSignature("Rcpp::StringVector(*_cl_charset_name)(SEXP,SEXP)");
            p__cl_charset_name = (Ptr__cl_charset_name)R_GetCCallable("RcppCWB", "_RcppCWB__cl_charset_name");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_charset_name(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline int _cl_struc_values(SEXP corpus, SEXP s_attribute, SEXP registry) {
        typedef SEXP(*Ptr__cl_struc_values)(SEXP,SEXP,SEXP);
        static Ptr__cl_struc_values p__cl_struc_values = NULL;
        if (p__cl_struc_values == NULL) {
            validateSignature("int(*_cl_struc_values)(SEXP,SEXP,SEXP)");
            p__cl_struc_values = (Ptr__cl_struc_values)R_GetCCallable("RcppCWB", "_RcppCWB__cl_struc_values");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_struc_values(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(s_attribute)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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 Rcpp::StringVector _corpus_data_dir(SEXP corpus, SEXP registry) {
        typedef SEXP(*Ptr__corpus_data_dir)(SEXP,SEXP);
        static Ptr__corpus_data_dir p__corpus_data_dir = NULL;
        if (p__corpus_data_dir == NULL) {
            validateSignature("Rcpp::StringVector(*_corpus_data_dir)(SEXP,SEXP)");
            p__corpus_data_dir = (Ptr__corpus_data_dir)R_GetCCallable("RcppCWB", "_RcppCWB__corpus_data_dir");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__corpus_data_dir(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::StringVector _corpus_info_file(SEXP corpus, SEXP registry) {
        typedef SEXP(*Ptr__corpus_info_file)(SEXP,SEXP);
        static Ptr__corpus_info_file p__corpus_info_file = NULL;
        if (p__corpus_info_file == NULL) {
            validateSignature("Rcpp::StringVector(*_corpus_info_file)(SEXP,SEXP)");
            p__corpus_info_file = (Ptr__corpus_info_file)R_GetCCallable("RcppCWB", "_RcppCWB__corpus_info_file");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__corpus_info_file(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::StringVector _corpus_full_name(SEXP corpus, SEXP registry) {
        typedef SEXP(*Ptr__corpus_full_name)(SEXP,SEXP);
        static Ptr__corpus_full_name p__corpus_full_name = NULL;
        if (p__corpus_full_name == NULL) {
            validateSignature("Rcpp::StringVector(*_corpus_full_name)(SEXP,SEXP)");
            p__corpus_full_name = (Ptr__corpus_full_name)R_GetCCallable("RcppCWB", "_RcppCWB__corpus_full_name");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__corpus_full_name(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::StringVector _corpus_p_attributes(SEXP corpus, SEXP registry) {
        typedef SEXP(*Ptr__corpus_p_attributes)(SEXP,SEXP);
        static Ptr__corpus_p_attributes p__corpus_p_attributes = NULL;
        if (p__corpus_p_attributes == NULL) {
            validateSignature("Rcpp::StringVector(*_corpus_p_attributes)(SEXP,SEXP)");
            p__corpus_p_attributes = (Ptr__corpus_p_attributes)R_GetCCallable("RcppCWB", "_RcppCWB__corpus_p_attributes");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__corpus_p_attributes(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::StringVector _corpus_s_attributes(SEXP corpus, SEXP registry) {
        typedef SEXP(*Ptr__corpus_s_attributes)(SEXP,SEXP);
        static Ptr__corpus_s_attributes p__corpus_s_attributes = NULL;
        if (p__corpus_s_attributes == NULL) {
            validateSignature("Rcpp::StringVector(*_corpus_s_attributes)(SEXP,SEXP)");
            p__corpus_s_attributes = (Ptr__corpus_s_attributes)R_GetCCallable("RcppCWB", "_RcppCWB__corpus_s_attributes");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__corpus_s_attributes(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::StringVector _corpus_properties(SEXP corpus, SEXP registry) {
        typedef SEXP(*Ptr__corpus_properties)(SEXP,SEXP);
        static Ptr__corpus_properties p__corpus_properties = NULL;
        if (p__corpus_properties == NULL) {
            validateSignature("Rcpp::StringVector(*_corpus_properties)(SEXP,SEXP)");
            p__corpus_properties = (Ptr__corpus_properties)R_GetCCallable("RcppCWB", "_RcppCWB__corpus_properties");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__corpus_properties(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::StringVector _corpus_property(SEXP corpus, SEXP registry, SEXP property) {
        typedef SEXP(*Ptr__corpus_property)(SEXP,SEXP,SEXP);
        static Ptr__corpus_property p__corpus_property = NULL;
        if (p__corpus_property == NULL) {
            validateSignature("Rcpp::StringVector(*_corpus_property)(SEXP,SEXP,SEXP)");
            p__corpus_property = (Ptr__corpus_property)R_GetCCallable("RcppCWB", "_RcppCWB__corpus_property");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__corpus_property(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(registry)), Shield<SEXP>(Rcpp::wrap(property)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline int _cl_load_corpus(SEXP corpus, SEXP registry) {
        typedef SEXP(*Ptr__cl_load_corpus)(SEXP,SEXP);
        static Ptr__cl_load_corpus p__cl_load_corpus = NULL;
        if (p__cl_load_corpus == NULL) {
            validateSignature("int(*_cl_load_corpus)(SEXP,SEXP)");
            p__cl_load_corpus = (Ptr__cl_load_corpus)R_GetCCallable("RcppCWB", "_RcppCWB__cl_load_corpus");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_load_corpus(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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 Rcpp::StringVector _cl_list_corpora() {
        typedef SEXP(*Ptr__cl_list_corpora)();
        static Ptr__cl_list_corpora p__cl_list_corpora = NULL;
        if (p__cl_list_corpora == NULL) {
            validateSignature("Rcpp::StringVector(*_cl_list_corpora)()");
            p__cl_list_corpora = (Ptr__cl_list_corpora)R_GetCCallable("RcppCWB", "_RcppCWB__cl_list_corpora");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cl_list_corpora();
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::StringVector _corpus_registry_dir(SEXP corpus) {
        typedef SEXP(*Ptr__corpus_registry_dir)(SEXP);
        static Ptr__corpus_registry_dir p__corpus_registry_dir = NULL;
        if (p__corpus_registry_dir == NULL) {
            validateSignature("Rcpp::StringVector(*_corpus_registry_dir)(SEXP)");
            p__corpus_registry_dir = (Ptr__corpus_registry_dir)R_GetCCallable("RcppCWB", "_RcppCWB__corpus_registry_dir");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__corpus_registry_dir(Shield<SEXP>(Rcpp::wrap(corpus)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline void _init_cqp() {
        typedef SEXP(*Ptr__init_cqp)();
        static Ptr__init_cqp p__init_cqp = NULL;
        if (p__init_cqp == NULL) {
            validateSignature("void(*_init_cqp)()");
            p__init_cqp = (Ptr__init_cqp)R_GetCCallable("RcppCWB", "_RcppCWB__init_cqp");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__init_cqp();
        }
        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 void _cqp_verbosity(int quietly, int verbose) {
        typedef SEXP(*Ptr__cqp_verbosity)(SEXP,SEXP);
        static Ptr__cqp_verbosity p__cqp_verbosity = NULL;
        if (p__cqp_verbosity == NULL) {
            validateSignature("void(*_cqp_verbosity)(int,int)");
            p__cqp_verbosity = (Ptr__cqp_verbosity)R_GetCCallable("RcppCWB", "_RcppCWB__cqp_verbosity");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cqp_verbosity(Shield<SEXP>(Rcpp::wrap(quietly)), Shield<SEXP>(Rcpp::wrap(verbose)));
        }
        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 Rcpp::StringVector _cqp_get_registry() {
        typedef SEXP(*Ptr__cqp_get_registry)();
        static Ptr__cqp_get_registry p__cqp_get_registry = NULL;
        if (p__cqp_get_registry == NULL) {
            validateSignature("Rcpp::StringVector(*_cqp_get_registry)()");
            p__cqp_get_registry = (Ptr__cqp_get_registry)R_GetCCallable("RcppCWB", "_RcppCWB__cqp_get_registry");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cqp_get_registry();
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline int _cqp_get_status() {
        typedef SEXP(*Ptr__cqp_get_status)();
        static Ptr__cqp_get_status p__cqp_get_status = NULL;
        if (p__cqp_get_status == NULL) {
            validateSignature("int(*_cqp_get_status)()");
            p__cqp_get_status = (Ptr__cqp_get_status)R_GetCCallable("RcppCWB", "_RcppCWB__cqp_get_status");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cqp_get_status();
        }
        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 SEXP _cqp_set_registry(SEXP registry_dir) {
        typedef SEXP(*Ptr__cqp_set_registry)(SEXP);
        static Ptr__cqp_set_registry p__cqp_set_registry = NULL;
        if (p__cqp_set_registry == NULL) {
            validateSignature("SEXP(*_cqp_set_registry)(SEXP)");
            p__cqp_set_registry = (Ptr__cqp_set_registry)R_GetCCallable("RcppCWB", "_RcppCWB__cqp_set_registry");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cqp_set_registry(Shield<SEXP>(Rcpp::wrap(registry_dir)));
        }
        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::StringVector _cqp_list_corpora() {
        typedef SEXP(*Ptr__cqp_list_corpora)();
        static Ptr__cqp_list_corpora p__cqp_list_corpora = NULL;
        if (p__cqp_list_corpora == NULL) {
            validateSignature("Rcpp::StringVector(*_cqp_list_corpora)()");
            p__cqp_list_corpora = (Ptr__cqp_list_corpora)R_GetCCallable("RcppCWB", "_RcppCWB__cqp_list_corpora");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cqp_list_corpora();
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline SEXP _cqp_query(SEXP corpus, SEXP subcorpus, SEXP query) {
        typedef SEXP(*Ptr__cqp_query)(SEXP,SEXP,SEXP);
        static Ptr__cqp_query p__cqp_query = NULL;
        if (p__cqp_query == NULL) {
            validateSignature("SEXP(*_cqp_query)(SEXP,SEXP,SEXP)");
            p__cqp_query = (Ptr__cqp_query)R_GetCCallable("RcppCWB", "_RcppCWB__cqp_query");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cqp_query(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(subcorpus)), Shield<SEXP>(Rcpp::wrap(query)));
        }
        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 _cqp_subcorpus_size(SEXP scorpus) {
        typedef SEXP(*Ptr__cqp_subcorpus_size)(SEXP);
        static Ptr__cqp_subcorpus_size p__cqp_subcorpus_size = NULL;
        if (p__cqp_subcorpus_size == NULL) {
            validateSignature("int(*_cqp_subcorpus_size)(SEXP)");
            p__cqp_subcorpus_size = (Ptr__cqp_subcorpus_size)R_GetCCallable("RcppCWB", "_RcppCWB__cqp_subcorpus_size");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cqp_subcorpus_size(Shield<SEXP>(Rcpp::wrap(scorpus)));
        }
        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 Rcpp::StringVector _cqp_list_subcorpora(SEXP inCorpus) {
        typedef SEXP(*Ptr__cqp_list_subcorpora)(SEXP);
        static Ptr__cqp_list_subcorpora p__cqp_list_subcorpora = NULL;
        if (p__cqp_list_subcorpora == NULL) {
            validateSignature("Rcpp::StringVector(*_cqp_list_subcorpora)(SEXP)");
            p__cqp_list_subcorpora = (Ptr__cqp_list_subcorpora)R_GetCCallable("RcppCWB", "_RcppCWB__cqp_list_subcorpora");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cqp_list_subcorpora(Shield<SEXP>(Rcpp::wrap(inCorpus)));
        }
        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::StringVector >(rcpp_result_gen);
    }

    inline Rcpp::IntegerMatrix _cqp_dump_subcorpus(SEXP inSubcorpus) {
        typedef SEXP(*Ptr__cqp_dump_subcorpus)(SEXP);
        static Ptr__cqp_dump_subcorpus p__cqp_dump_subcorpus = NULL;
        if (p__cqp_dump_subcorpus == NULL) {
            validateSignature("Rcpp::IntegerMatrix(*_cqp_dump_subcorpus)(SEXP)");
            p__cqp_dump_subcorpus = (Ptr__cqp_dump_subcorpus)R_GetCCallable("RcppCWB", "_RcppCWB__cqp_dump_subcorpus");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cqp_dump_subcorpus(Shield<SEXP>(Rcpp::wrap(inSubcorpus)));
        }
        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::IntegerMatrix >(rcpp_result_gen);
    }

    inline Rcpp::IntegerMatrix _cqp_subcorpus_regions(SEXP subcorpus) {
        typedef SEXP(*Ptr__cqp_subcorpus_regions)(SEXP);
        static Ptr__cqp_subcorpus_regions p__cqp_subcorpus_regions = NULL;
        if (p__cqp_subcorpus_regions == NULL) {
            validateSignature("Rcpp::IntegerMatrix(*_cqp_subcorpus_regions)(SEXP)");
            p__cqp_subcorpus_regions = (Ptr__cqp_subcorpus_regions)R_GetCCallable("RcppCWB", "_RcppCWB__cqp_subcorpus_regions");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cqp_subcorpus_regions(Shield<SEXP>(Rcpp::wrap(subcorpus)));
        }
        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::IntegerMatrix >(rcpp_result_gen);
    }

    inline SEXP _cqp_drop_subcorpus(SEXP inSubcorpus) {
        typedef SEXP(*Ptr__cqp_drop_subcorpus)(SEXP);
        static Ptr__cqp_drop_subcorpus p__cqp_drop_subcorpus = NULL;
        if (p__cqp_drop_subcorpus == NULL) {
            validateSignature("SEXP(*_cqp_drop_subcorpus)(SEXP)");
            p__cqp_drop_subcorpus = (Ptr__cqp_drop_subcorpus)R_GetCCallable("RcppCWB", "_RcppCWB__cqp_drop_subcorpus");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cqp_drop_subcorpus(Shield<SEXP>(Rcpp::wrap(inSubcorpus)));
        }
        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 _check_corpus(SEXP corpus) {
        typedef SEXP(*Ptr__check_corpus)(SEXP);
        static Ptr__check_corpus p__check_corpus = NULL;
        if (p__check_corpus == NULL) {
            validateSignature("int(*_check_corpus)(SEXP)");
            p__check_corpus = (Ptr__check_corpus)R_GetCCallable("RcppCWB", "_RcppCWB__check_corpus");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__check_corpus(Shield<SEXP>(Rcpp::wrap(corpus)));
        }
        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 int _cqp_load_corpus(SEXP corpus, SEXP registry) {
        typedef SEXP(*Ptr__cqp_load_corpus)(SEXP,SEXP);
        static Ptr__cqp_load_corpus p__cqp_load_corpus = NULL;
        if (p__cqp_load_corpus == NULL) {
            validateSignature("int(*_cqp_load_corpus)(SEXP,SEXP)");
            p__cqp_load_corpus = (Ptr__cqp_load_corpus)R_GetCCallable("RcppCWB", "_RcppCWB__cqp_load_corpus");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cqp_load_corpus(Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(registry)));
        }
        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 SEXP _region_matrix_to_subcorpus(Rcpp::IntegerMatrix region_matrix, SEXP corpus, SEXP subcorpus) {
        typedef SEXP(*Ptr__region_matrix_to_subcorpus)(SEXP,SEXP,SEXP);
        static Ptr__region_matrix_to_subcorpus p__region_matrix_to_subcorpus = NULL;
        if (p__region_matrix_to_subcorpus == NULL) {
            validateSignature("SEXP(*_region_matrix_to_subcorpus)(Rcpp::IntegerMatrix,SEXP,SEXP)");
            p__region_matrix_to_subcorpus = (Ptr__region_matrix_to_subcorpus)R_GetCCallable("RcppCWB", "_RcppCWB__region_matrix_to_subcorpus");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__region_matrix_to_subcorpus(Shield<SEXP>(Rcpp::wrap(region_matrix)), Shield<SEXP>(Rcpp::wrap(corpus)), Shield<SEXP>(Rcpp::wrap(subcorpus)));
        }
        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 _cwb_makeall(SEXP x, SEXP registry_dir, SEXP p_attribute) {
        typedef SEXP(*Ptr__cwb_makeall)(SEXP,SEXP,SEXP);
        static Ptr__cwb_makeall p__cwb_makeall = NULL;
        if (p__cwb_makeall == NULL) {
            validateSignature("int(*_cwb_makeall)(SEXP,SEXP,SEXP)");
            p__cwb_makeall = (Ptr__cwb_makeall)R_GetCCallable("RcppCWB", "_RcppCWB__cwb_makeall");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cwb_makeall(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(registry_dir)), Shield<SEXP>(Rcpp::wrap(p_attribute)));
        }
        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 int _cwb_huffcode(SEXP x, SEXP registry_dir, SEXP p_attribute) {
        typedef SEXP(*Ptr__cwb_huffcode)(SEXP,SEXP,SEXP);
        static Ptr__cwb_huffcode p__cwb_huffcode = NULL;
        if (p__cwb_huffcode == NULL) {
            validateSignature("int(*_cwb_huffcode)(SEXP,SEXP,SEXP)");
            p__cwb_huffcode = (Ptr__cwb_huffcode)R_GetCCallable("RcppCWB", "_RcppCWB__cwb_huffcode");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cwb_huffcode(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(registry_dir)), Shield<SEXP>(Rcpp::wrap(p_attribute)));
        }
        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 int _cwb_compress_rdx(SEXP x, SEXP registry_dir, SEXP p_attribute) {
        typedef SEXP(*Ptr__cwb_compress_rdx)(SEXP,SEXP,SEXP);
        static Ptr__cwb_compress_rdx p__cwb_compress_rdx = NULL;
        if (p__cwb_compress_rdx == NULL) {
            validateSignature("int(*_cwb_compress_rdx)(SEXP,SEXP,SEXP)");
            p__cwb_compress_rdx = (Ptr__cwb_compress_rdx)R_GetCCallable("RcppCWB", "_RcppCWB__cwb_compress_rdx");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cwb_compress_rdx(Shield<SEXP>(Rcpp::wrap(x)), Shield<SEXP>(Rcpp::wrap(registry_dir)), Shield<SEXP>(Rcpp::wrap(p_attribute)));
        }
        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 int _cwb_encode(SEXP regfile, SEXP data_dir, SEXP vrt_dir, SEXP encoding, Rcpp::StringVector p_attributes, Rcpp::StringVector s_attributes_anno, Rcpp::StringVector s_attributes_noanno, int skip_blank_lines, int strip_whitespace, int xml, int quiet, int verbosity) {
        typedef SEXP(*Ptr__cwb_encode)(SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP,SEXP);
        static Ptr__cwb_encode p__cwb_encode = NULL;
        if (p__cwb_encode == NULL) {
            validateSignature("int(*_cwb_encode)(SEXP,SEXP,SEXP,SEXP,Rcpp::StringVector,Rcpp::StringVector,Rcpp::StringVector,int,int,int,int,int)");
            p__cwb_encode = (Ptr__cwb_encode)R_GetCCallable("RcppCWB", "_RcppCWB__cwb_encode");
        }
        RObject rcpp_result_gen;
        {
            RNGScope RCPP_rngScope_gen;
            rcpp_result_gen = p__cwb_encode(Shield<SEXP>(Rcpp::wrap(regfile)), Shield<SEXP>(Rcpp::wrap(data_dir)), Shield<SEXP>(Rcpp::wrap(vrt_dir)), Shield<SEXP>(Rcpp::wrap(encoding)), Shield<SEXP>(Rcpp::wrap(p_attributes)), Shield<SEXP>(Rcpp::wrap(s_attributes_anno)), Shield<SEXP>(Rcpp::wrap(s_attributes_noanno)), Shield<SEXP>(Rcpp::wrap(skip_blank_lines)), Shield<SEXP>(Rcpp::wrap(strip_whitespace)), Shield<SEXP>(Rcpp::wrap(xml)), Shield<SEXP>(Rcpp::wrap(quiet)), Shield<SEXP>(Rcpp::wrap(verbosity)));
        }
        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);
    }

}

#endif // RCPP_RcppCWB_RCPPEXPORTS_H_GEN_
